@serifpersia/dango 3.4.4 → 3.4.5

package/server/dist/lib/potoken.js

@@ -0,0 +1,135 @@
+import logger from '../logger.js';
+import { parseJsonBody } from '../utils/http.utils.js';
+import { getInnertube } from './ytmusic.js';
+const REQUEST_KEY = 'O43z0dpjhgX20SCx4KAo';
+const INTEGRITY_TTL_MS = 10 * 60 * 60 * 1000;
+const POT_CACHE_MS = 6 * 60 * 60 * 1000;
+let minter = null;
+let minterFetchedAt = 0;
+let bootstrapPromise = null;
+let bootstrapFailedAt = 0;
+const BOOTSTRAP_FAIL_COOLDOWN_MS = 60 * 1000;
+const potCache = new Map();
+// BotGuard needs browser globals to execute. They are installed once and kept
+// for the process lifetime: the minter's callbacks read them lazily at mint
+// time, long after bootstrap completes, so scoping them to bootstrap breaks
+// minting with `window is not defined`.
+async function setupDom() {
+    const g = globalThis;
+    if ('navigator' in g && g.yt)
+        return;
+    const { JSDOM, VirtualConsole } = await import('jsdom');
+    const virtualConsole = new VirtualConsole();
+    const dom = new JSDOM('<!DOCTYPE html><html lang="en"><head><title></title></head><body></body></html>', {
+        url: 'https://www.youtube.com',
+        referrer: 'https://www.youtube.com/',
+        virtualConsole,
+    });
+    Object.assign(g, {
+        window: dom.window,
+        document: dom.window.document,
+        location: dom.window.location,
+        origin: dom.window.origin,
+    });
+    if (!('navigator' in g)) {
+        Object.defineProperty(g, 'navigator', {
+            value: dom.window.navigator,
+            writable: true,
+            configurable: true,
+        });
+    }
+}
+async function buildMinter() {
+    const [{ BotGuardClient }, { WebPoMinter }, { buildURL, getHeaders, USER_AGENT }] = await Promise.all([
+        import('bgutils-js/botguard'),
+        import('bgutils-js/webpo'),
+        import('bgutils-js/utils'),
+    ]);
+    const yt = await getInnertube();
+    const pageResponse = await fetch('https://www.youtube.com', {
+        headers: {
+            accept: '*/*',
+            'accept-language': 'en-US,en;q=0.7',
+            'user-agent': USER_AGENT,
+        },
+    });
+    const pageHtml = await pageResponse.text();
+    const ytConfig = pageHtml.match(/ytcfg\.set\(({.+?})\);/s)?.[1];
+    if (ytConfig) {
+        const win = globalThis.window;
+        if (win)
+            win.yt = { config_: JSON.parse(ytConfig) };
+    }
+    const challenge = (await yt.getAttestationChallenge('ENGAGEMENT_TYPE_UNBOUND'));
+    const bgc = challenge.bg_challenge;
+    const interpreterUrl = bgc?.interpreter_url?.private_do_not_access_or_else_trusted_resource_url_wrapped_value;
+    if (!bgc?.program || !bgc.global_name || !interpreterUrl) {
+        throw new Error('No BotGuard challenge in response');
+    }
+    const bgScript = await (await fetch(`https:${interpreterUrl}`)).text();
+    if (!bgScript)
+        throw new Error('Could not load BotGuard VM');
+    new Function(bgScript)();
+    const botGuard = await BotGuardClient.create({
+        program: bgc.program,
+        globalName: bgc.global_name,
+        globalObject: globalThis,
+    });
+    const webPoSignalOutput = [];
+    const botguardResponse = await botGuard.snapshot({ webPoSignalOutput });
+    const itResponse = await fetch(buildURL('GenerateIT', true), {
+        method: 'POST',
+        headers: getHeaders(),
+        body: JSON.stringify([REQUEST_KEY, botguardResponse]),
+    });
+    const [integrityToken, estimatedTtlSecs, mintRefreshThreshold, websafeFallbackToken] = await parseJsonBody(itResponse);
+    if (!integrityToken)
+        throw new Error('Integrity token request failed');
+    logger.info('[pot] minter ready (integrity ttl %ss)', estimatedTtlSecs);
+    return WebPoMinter.create({
+        integrityToken,
+        estimatedTtlSecs,
+        mintRefreshThreshold,
+        websafeFallbackToken,
+    }, webPoSignalOutput);
+}
+async function getMinter() {
+    if (minter && Date.now() - minterFetchedAt < INTEGRITY_TTL_MS)
+        return minter;
+    if (Date.now() - bootstrapFailedAt < BOOTSTRAP_FAIL_COOLDOWN_MS) {
+        throw new Error('PoToken bootstrap cooling down');
+    }
+    if (!bootstrapPromise) {
+        bootstrapPromise = (async () => {
+            await setupDom();
+            const m = await buildMinter();
+            minter = m;
+            minterFetchedAt = Date.now();
+            return m;
+        })().catch((err) => {
+            bootstrapPromise = null;
+            bootstrapFailedAt = Date.now();
+            throw err;
+        });
+    }
+    return bootstrapPromise;
+}
+export async function mintPoToken(videoId) {
+    const cached = potCache.get(videoId);
+    if (cached && Date.now() - cached.fetchedAt < POT_CACHE_MS)
+        return cached.pot;
+    const m = await getMinter();
+    const pot = await m.mintAsWebsafeString(videoId);
+    potCache.set(videoId, { pot, fetchedAt: Date.now() });
+    return pot;
+}
+export function resetPoTokens(videoId) {
+    if (videoId)
+        potCache.delete(videoId);
+    else {
+        potCache.clear();
+        minter = null;
+        minterFetchedAt = 0;
+        bootstrapPromise = null;
+    }
+}

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

@@ -5,30 +5,11 @@ import { performMangaWriteTransactionAsync, performWriteTransactionAsync } from
 import logger from '../../logger.js';
 import { searchAnilistMangaByTitle, getMangaMetaById, getMangaMetaByMalId } from '../anilist.js';
 import { fetchMalMangaList, mapMalMangaStatusCode } from '../mal.js';
+import { readTrackerSyncState, resolveStatus, } from './sync-state.js';
 const TOKEN_KEY = 'tracker_anilist_token';
 const MANGA_SYNC_STATE_KEY = 'tracker_anilist_manga_sync_state';
 const MANGA_PROVIDER = 'anilist';
 const MAX_TITLE_LOOKUPS_PER_SYNC = 25;
-async function readMangaSyncState(db) {
-    const row = await SettingsRepository.getByKey(db, MANGA_SYNC_STATE_KEY);
-    if (!row?.value)
-        return {};
-    try {
-        return JSON.parse(row.value);
-    }
-    catch {
-        return {};
-    }
-}
-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 };
-}
 function parseChapterProgress(value) {
     if (value == null)
         return 0;
@@ -122,7 +103,7 @@ export async function syncAniListManga(db, mangaDb, opts = {}) {
     const viewer = await tracker.getViewer();
     const remoteEntries = await tracker.fetchUserMangaList(viewer.id);
     const localItems = await MangaLibraryRepository.getAll(mangaDb);
-    const syncState = await readMangaSyncState(db);
+    const syncState = await readTrackerSyncState(db, MANGA_SYNC_STATE_KEY);
     const remoteByMediaId = new Map();
     for (const entry of remoteEntries)
         remoteByMediaId.set(entry.mediaId, entry);
@@ -618,7 +599,7 @@ export async function insertMangaImportEntries(db, mangaDb, items, eraseAnilistR
     if (items.length === 0)
         return 0;
     const now = Math.floor(Date.now() / 1000);
-    const syncState = await readMangaSyncState(db);
+    const syncState = await readTrackerSyncState(db, MANGA_SYNC_STATE_KEY);
     await performMangaWriteTransactionAsync(mangaDb, async (tx) => {
         if (eraseAnilistRows) {
             for (const row of await MangaLibraryRepository.getAll(tx)) {

package/server/dist/lib/tracker/sync-state.js

@@ -0,0 +1,21 @@
+import { SettingsRepository } from '../../repositories/settings.repository.js';
+export async function readTrackerSyncState(db, key) {
+    const row = await SettingsRepository.getByKey(db, key);
+    if (!row?.value)
+        return {};
+    try {
+        return JSON.parse(row.value);
+    }
+    catch {
+        return {};
+    }
+}
+export 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 };
+}

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

@@ -11,33 +11,14 @@ import { fetchMalUserList } from '../mal.js';
 import { offlineDb } from '../offline-db.js';
 import { getShowMetaById, getShowMetaByMalId, isAnilistRateLimited, searchAnilistByTitle, } from '../anilist.js';
 import { kitsuSearchAnime } from '../kitsu.js';
+import { readTrackerSyncState, resolveStatus, } from './sync-state.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;
@@ -47,7 +28,7 @@ export async function syncAniList(db) {
     const viewer = await tracker.getViewer();
     const remoteEntries = await tracker.fetchUserAnimeList(viewer.id);
     const localItems = await WatchlistRepository.getAll(db);
-    const syncState = await readSyncState(db);
+    const syncState = await readTrackerSyncState(db, SYNC_STATE_KEY);
     const remoteByMediaId = new Map();
     for (const entry of remoteEntries)
         remoteByMediaId.set(entry.mediaId, entry);
@@ -299,7 +280,7 @@ export async function importFromUsername(db, username, erase = false) {
     if (entries.length === 0)
         return 0;
     const now = Math.floor(Date.now() / 1000);
-    const syncState = await readSyncState(db);
+    const syncState = await readTrackerSyncState(db, SYNC_STATE_KEY);
     await performWriteTransactionAsync(db, async (tx) => {
         if (erase)
             await SettingsRepository.clearWatchlist(tx);

package/server/dist/lib/ump.js

@@ -0,0 +1,106 @@
+const MEDIA_HEADER = 20;
+const MEDIA = 21;
+const STREAM_PROTECTION_STATUS = 58;
+function readVarint(buf, pos) {
+    if (pos >= buf.length)
+        return null;
+    const prefix = buf[pos];
+    let size = 0;
+    for (let shift = 1; shift <= 5; shift++) {
+        if ((prefix & (128 >> (shift - 1))) === 0) {
+            size = shift;
+            break;
+        }
+    }
+    if (size < 1 || pos + size > buf.length)
+        return null;
+    if (size === 1)
+        return [prefix, pos + 1];
+    if (size === 5) {
+        const value = buf[pos + 1] + buf[pos + 2] * 256 + buf[pos + 3] * 65536 + buf[pos + 4] * 16777216;
+        return [value >>> 0, pos + 5];
+    }
+    const lowBits = 8 - size;
+    let value = prefix & ((1 << lowBits) - 1);
+    for (let i = 1; i < size; i++) {
+        value += buf[pos + i] * 2 ** (lowBits + 8 * (i - 1));
+    }
+    return [value, pos + size];
+}
+function readStatusField(payload) {
+    let pos = 0;
+    while (pos < payload.length) {
+        const key = payload[pos++];
+        const field = key >> 3;
+        const wire = key & 7;
+        if (wire !== 0)
+            break;
+        const decoded = readVarint(payload, pos);
+        if (!decoded)
+            break;
+        if (field === 1)
+            return decoded[0];
+        pos = decoded[1];
+    }
+    return 1;
+}
+export function parseUmpResponse(buf, carry) {
+    const mediaChunks = [];
+    let status = 1;
+    let nextCarry = carry;
+    let pos = 0;
+    if (nextCarry) {
+        const t = readVarint(buf, pos);
+        const s = t && readVarint(buf, t[1]);
+        if (t && s && t[0] === MEDIA_HEADER) {
+            pos = s[1] + s[0];
+        }
+        const ct = readVarint(buf, pos);
+        const cs = ct && readVarint(buf, ct[1]);
+        if (ct && cs && ct[0] === nextCarry.pendingType) {
+            pos = cs[1];
+            const take = Math.min(cs[0], buf.length - pos);
+            nextCarry.chunks.push(buf.subarray(pos, pos + take));
+            nextCarry.remaining = cs[0] - take;
+            pos += take;
+            if (nextCarry.remaining <= 0) {
+                const full = Buffer.concat(nextCarry.chunks);
+                nextCarry = null;
+                if (ct[0] === MEDIA && full.length > 1)
+                    mediaChunks.push(full.subarray(1));
+            }
+        }
+        else {
+            nextCarry = null;
+        }
+    }
+    while (pos < buf.length) {
+        const t = readVarint(buf, pos);
+        if (!t)
+            break;
+        const s = readVarint(buf, t[1]);
+        if (!s)
+            break;
+        const [type, size] = [t[0], s[0]];
+        pos = s[1];
+        const available = buf.length - pos;
+        if (size > available) {
+            nextCarry = {
+                pendingType: type,
+                remaining: size - available,
+                chunks: [buf.subarray(pos)],
+            };
+            break;
+        }
+        const payload = buf.subarray(pos, pos + size);
+        pos += size;
+        if (type === MEDIA) {
+            if (payload.length > 1)
+                mediaChunks.push(payload.subarray(1));
+        }
+        else if (type === STREAM_PROTECTION_STATUS) {
+            status = readStatusField(payload);
+        }
+    }
+    return { media: Buffer.concat(mediaChunks), status, carry: nextCarry };
+}

package/server/dist/providers/remote-loader.js

@@ -238,7 +238,8 @@ function createCtx(cache) {
                     ? { url: urlOrOptions, ...(maybeOptions ?? {}) }
                     : urlOrOptions);
                 const { url, ...rest } = opts;
-                const res = await gotScraping(url, {
+                const res = await gotScraping({
+                    url: url,
                     method: 'GET',
                     responseType: 'text',
                     throwHttpErrors: false,

package/server/dist/repositories/asmr.repository.js

@@ -1,48 +1,13 @@
 import { eq, inArray, sql } from 'drizzle-orm';
 import { getDrizzle } from '../db/drizzle.js';
-import { asmrLibrary, asmrProgress } from '../db/schema-asmr.js';
-export const ASMR_STATUSES = [
-    'Listening',
-    'Completed',
-    'On-Hold',
-    'Dropped',
-    'Planned',
-];
+import { asmrProgress } from '../db/schema-asmr.js';
+import { makeLibraryRepo } from './library.repository.js';
+export const ASMR_STATUSES = ['Listening', 'Completed', 'On-Hold', 'Dropped', 'Planned'];
 export function buildAsmrId(rjCode) {
     return String(rjCode).trim().toUpperCase();
 }
 export const AsmrLibraryRepository = {
-    getById: async (db, id) => {
-        const rows = await getDrizzle(db).all(sql `SELECT * FROM asmr_library WHERE id = ${id}`);
-        return rows[0];
-    },
-    exists: async (db, id) => {
-        const rows = await getDrizzle(db).all(sql `SELECT EXISTS(SELECT 1 FROM asmr_library WHERE id = ${id}) as inLibrary`);
-        return !!(rows[0] && rows[0].inLibrary);
-    },
-    getAll: (db, status, limit, offset) => {
-        const q = sql `SELECT * FROM asmr_library`;
-        if (status && status !== 'All') {
-            q.append(sql ` WHERE status = ${status}`);
-        }
-        q.append(sql ` ORDER BY updatedAt DESC`);
-        if (limit !== undefined && offset !== undefined) {
-            q.append(sql ` LIMIT ${limit} OFFSET ${offset}`);
-        }
-        return getDrizzle(db).all(q);
-    },
-    getCount: async (db, status) => {
-        if (status && status !== 'All') {
-            const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) as total FROM asmr_library WHERE status = ${status}`);
-            return rows[0]?.total || 0;
-        }
-        const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) as total FROM asmr_library`);
-        return rows[0]?.total || 0;
-    },
-    getIds: async (db) => {
-        const rows = await getDrizzle(db).all(sql `SELECT id FROM asmr_library`);
-        return rows.map((r) => r.id);
-    },
+    ...makeLibraryRepo('asmr_library'),
     upsert: (db, data) => getDrizzle(db).run(sql `
       INSERT INTO asmr_library (id, rjCode, title, thumbnail, status, isAdult, updatedAt)
       VALUES (${data.id}, ${data.rjCode}, ${data.title}, ${data.thumbnail}, ${data.status}, ${data.isAdult ? 1 : 0}, strftime('%s', 'now'))
@@ -53,22 +18,8 @@ export const AsmrLibraryRepository = {
          status = COALESCE(NULLIF(EXCLUDED.status, ''), asmr_library.status),
          isAdult = COALESCE(EXCLUDED.isAdult, asmr_library.isAdult),
          updatedAt = strftime('%s', 'now')`),
-    updateStatus: (db, id, status) => getDrizzle(db).run(sql `
-      UPDATE asmr_library SET status = ${status}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
-    updateStatusMany: (db, ids, status) => {
-        if (ids.length === 0)
-            return Promise.resolve();
-        return getDrizzle(db).run(sql `
-      UPDATE asmr_library SET status = ${status}, updatedAt = strftime('%s', 'now') WHERE id IN (${sql.join(ids.map((id) => sql `${id}`), sql `, `)})`);
-    },
     touchProgress: (db, id, progress) => getDrizzle(db).run(sql `
       UPDATE asmr_library SET lastTrackIndex = ${progress.trackIndex}, lastTrackLabel = ${progress.trackLabel}, lastPosition = ${progress.position}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
-    delete: (db, id) => getDrizzle(db).delete(asmrLibrary).where(eq(asmrLibrary.id, id)),
-    deleteMany: (db, ids) => {
-        if (ids.length === 0)
-            return Promise.resolve();
-        return getDrizzle(db).delete(asmrLibrary).where(inArray(asmrLibrary.id, ids));
-    },
 };
 export const AsmrProgressRepository = {
     getByWork: (db, workId) => getDrizzle(db).all(sql `

package/server/dist/repositories/library.repository.js

@@ -36,6 +36,52 @@ async function clearTables(db, tables) {
         }
     }
 }
+export function makeLibraryRepo(table) {
+    const t = sql.raw(`"${table}"`);
+    return {
+        getById: async (db, id) => {
+            const rows = await getDrizzle(db).all(sql `SELECT * FROM ${t} WHERE id = ${id}`);
+            return rows[0];
+        },
+        getAll: (db, status, limit, offset) => {
+            const q = sql `SELECT * FROM ${t}`;
+            if (status && status !== 'All') {
+                q.append(sql ` WHERE status = ${status}`);
+            }
+            q.append(sql ` ORDER BY updatedAt DESC`);
+            if (limit !== undefined && offset !== undefined) {
+                q.append(sql ` LIMIT ${limit} OFFSET ${offset}`);
+            }
+            return getDrizzle(db).all(q);
+        },
+        getCount: async (db, status) => {
+            if (status && status !== 'All') {
+                const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) as total FROM ${t} WHERE status = ${status}`);
+                return rows[0]?.total || 0;
+            }
+            const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) as total FROM ${t}`);
+            return rows[0]?.total || 0;
+        },
+        getIds: async (db) => {
+            const rows = await getDrizzle(db).all(sql `SELECT id FROM ${t}`);
+            return rows.map((r) => r.id);
+        },
+        updateStatus: (db, id, status) => getDrizzle(db).run(sql `
+      UPDATE ${t} SET status = ${status}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
+        updateStatusMany: (db, ids, status) => {
+            if (ids.length === 0)
+                return Promise.resolve();
+            return getDrizzle(db).run(sql `
+      UPDATE ${t} SET status = ${status}, updatedAt = strftime('%s', 'now') WHERE id IN (${sql.join(ids.map((id) => sql `${id}`), sql `, `)})`);
+        },
+        delete: (db, id) => getDrizzle(db).run(sql `DELETE FROM ${t} WHERE id = ${id}`),
+        deleteMany: (db, ids) => {
+            if (ids.length === 0)
+                return Promise.resolve();
+            return getDrizzle(db).run(sql `DELETE FROM ${t} WHERE id IN (${sql.join(ids.map((id) => sql `${id}`), sql `, `)})`);
+        },
+    };
+}
 export const LibraryRepository = {
     countAll: (db) => countTables(db, LIBRARY_TABLES),
     clearAll: (db) => clearTables(db, LIBRARY_TABLES),

package/server/dist/repositories/manga.repository.js

@@ -1,48 +1,13 @@
 import { eq, inArray, sql } from 'drizzle-orm';
 import { getDrizzle } from '../db/drizzle.js';
 import { mangaLibrary, mangaProgress } from '../db/schema-manga.js';
-export const MANGA_STATUSES = [
-    'Reading',
-    'Completed',
-    'On-Hold',
-    'Dropped',
-    'Planned',
-];
+import { makeLibraryRepo } from './library.repository.js';
+export const MANGA_STATUSES = ['Reading', 'Completed', 'On-Hold', 'Dropped', 'Planned'];
 export function buildMangaId(provider, mangaId) {
     return `${provider.toLowerCase()}:${mangaId}`;
 }
 export const MangaLibraryRepository = {
-    getById: async (db, id) => {
-        const rows = await getDrizzle(db).all(sql `SELECT * FROM manga_library WHERE id = ${id}`);
-        return rows[0];
-    },
-    exists: async (db, id) => {
-        const rows = await getDrizzle(db).all(sql `SELECT EXISTS(SELECT 1 FROM manga_library WHERE id = ${id}) as inLibrary`);
-        return !!(rows[0] && rows[0].inLibrary);
-    },
-    getAll: (db, status, limit, offset) => {
-        const q = sql `SELECT * FROM manga_library`;
-        if (status && status !== 'All') {
-            q.append(sql ` WHERE status = ${status}`);
-        }
-        q.append(sql ` ORDER BY updatedAt DESC`);
-        if (limit !== undefined && offset !== undefined) {
-            q.append(sql ` LIMIT ${limit} OFFSET ${offset}`);
-        }
-        return getDrizzle(db).all(q);
-    },
-    getCount: async (db, status) => {
-        if (status && status !== 'All') {
-            const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) as total FROM manga_library WHERE status = ${status}`);
-            return rows[0]?.total || 0;
-        }
-        const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) as total FROM manga_library`);
-        return rows[0]?.total || 0;
-    },
-    getIds: async (db) => {
-        const rows = await getDrizzle(db).all(sql `SELECT id FROM manga_library`);
-        return rows.map((r) => r.id);
-    },
+    ...makeLibraryRepo('manga_library'),
     upsert: (db, data) => getDrizzle(db).run(sql `
       INSERT INTO manga_library (id, provider, mangaId, title, cover, status, author, altTitle, contentRating, anilistId, anilistIdSource, updatedAt)
       VALUES (${data.id}, ${data.provider}, ${data.mangaId}, ${data.title}, ${data.cover}, ${data.status}, ${data.author || null}, ${data.altTitle || null}, ${data.contentRating || null}, ${data.anilistId ?? null}, ${data.anilistIdSource ?? null}, strftime('%s', 'now'))
@@ -64,24 +29,10 @@ export const MangaLibraryRepository = {
             .where(eq(mangaLibrary.id, id))
         : getDrizzle(db).update(mangaLibrary).set({ anilistId }).where(eq(mangaLibrary.id, id)),
     getByAnilistId: (db, anilistId) => getDrizzle(db).all(sql `SELECT * FROM manga_library WHERE anilistId = ${anilistId}`),
-    updateStatus: (db, id, status) => getDrizzle(db).run(sql `
-      UPDATE manga_library SET status = ${status}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
-    updateStatusMany: (db, ids, status) => {
-        if (ids.length === 0)
-            return Promise.resolve();
-        return getDrizzle(db).run(sql `
-      UPDATE manga_library SET status = ${status}, updatedAt = strftime('%s', 'now') WHERE id IN (${sql.join(ids.map((id) => sql `${id}`), sql `, `)})`);
-    },
     touchProgress: (db, id, progress) => getDrizzle(db).run(sql `
       UPDATE manga_library SET lastChapterId = ${progress.chapterId}, lastChapterNumber = ${progress.chapterNumber}, lastPage = ${progress.page}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
     setProgressPointer: (db, id, chapterNumber) => getDrizzle(db).run(sql `
       UPDATE manga_library SET lastChapterNumber = ${chapterNumber}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
-    delete: (db, id) => getDrizzle(db).delete(mangaLibrary).where(eq(mangaLibrary.id, id)),
-    deleteMany: (db, ids) => {
-        if (ids.length === 0)
-            return Promise.resolve();
-        return getDrizzle(db).delete(mangaLibrary).where(inArray(mangaLibrary.id, ids));
-    },
 };
 export const MangaProgressRepository = {
     getByManga: (db, mangaId) => getDrizzle(db).all(sql `

package/server/dist/repositories/settings.repository.js

@@ -11,6 +11,14 @@ export const SettingsRepository = {
         .values({ key, value })
         .onConflictDoUpdate({ target: settings.key, set: { value } }),
     deleteByKey: (db, key) => getDrizzle(db).delete(settings).where(eq(settings.key, key)),
+    readContinueFlags: async (db, ignoreKey, listOnlyKey) => {
+        const ignoreRow = await SettingsRepository.getByKey(db, ignoreKey);
+        const listOnlyRow = await SettingsRepository.getByKey(db, listOnlyKey);
+        return {
+            ignoreAdult: ignoreRow ? ignoreRow.value !== 'false' : true,
+            listOnly: listOnlyRow ? listOnlyRow.value === 'true' || listOnlyRow.value === '1' : false,
+        };
+    },
     clearWatchlist: (db) => getDrizzle(db).delete(watchlist),
     upsertWatchlistBatch: (db, shows) => {
         if (shows.length === 0)

package/server/dist/repositories/tv.repository.js

@@ -1,6 +1,7 @@
 import { eq, inArray, sql } from 'drizzle-orm';
 import { getDrizzle } from '../db/drizzle.js';
-import { tvLibrary, tvProgress } from '../db/schema-tv.js';
+import { tvProgress } from '../db/schema-tv.js';
+import { makeLibraryRepo } from './library.repository.js';
 export const TV_STATUSES = ['Watching', 'Completed', 'On-Hold', 'Dropped', 'Planned'];
 export function buildTvId(mediaType, tmdbId) {
     const t = String(mediaType).toLowerCase() === 'movie' ? 'movie' : 'tv';
@@ -14,37 +15,7 @@ export function normalizeTvMediaId(raw) {
     return s;
 }
 export const TvLibraryRepository = {
-    getById: async (db, id) => {
-        const rows = await getDrizzle(db).all(sql `SELECT * FROM tv_library WHERE id = ${id}`);
-        return rows[0];
-    },
-    exists: async (db, id) => {
-        const rows = await getDrizzle(db).all(sql `SELECT EXISTS(SELECT 1 FROM tv_library WHERE id = ${id}) as inLibrary`);
-        return !!(rows[0] && rows[0].inLibrary);
-    },
-    getAll: (db, status, limit, offset) => {
-        const q = sql `SELECT * FROM tv_library`;
-        if (status && status !== 'All') {
-            q.append(sql ` WHERE status = ${status}`);
-        }
-        q.append(sql ` ORDER BY updatedAt DESC`);
-        if (limit !== undefined && offset !== undefined) {
-            q.append(sql ` LIMIT ${limit} OFFSET ${offset}`);
-        }
-        return getDrizzle(db).all(q);
-    },
-    getCount: async (db, status) => {
-        if (status && status !== 'All') {
-            const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) as total FROM tv_library WHERE status = ${status}`);
-            return rows[0]?.total || 0;
-        }
-        const rows = await getDrizzle(db).all(sql `SELECT COUNT(*) as total FROM tv_library`);
-        return rows[0]?.total || 0;
-    },
-    getIds: async (db) => {
-        const rows = await getDrizzle(db).all(sql `SELECT id FROM tv_library`);
-        return rows.map((r) => r.id);
-    },
+    ...makeLibraryRepo('tv_library'),
     upsert: (db, data) => getDrizzle(db).run(sql `
       INSERT INTO tv_library (id, tmdbId, mediaType, title, poster, backdrop, year, overview, status, adult, updatedAt)
       VALUES (${data.id}, ${data.tmdbId}, ${data.mediaType}, ${data.title}, ${data.poster}, ${data.backdrop || null}, ${data.year || null}, ${data.overview || null}, ${data.status}, ${data.adult ? 1 : 0}, strftime('%s', 'now'))
@@ -59,22 +30,8 @@ export const TvLibraryRepository = {
          status = COALESCE(NULLIF(EXCLUDED.status, ''), tv_library.status),
          adult = COALESCE(EXCLUDED.adult, tv_library.adult),
          updatedAt = strftime('%s', 'now')`),
-    updateStatus: (db, id, status) => getDrizzle(db).run(sql `
-      UPDATE tv_library SET status = ${status}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
-    updateStatusMany: (db, ids, status) => {
-        if (ids.length === 0)
-            return Promise.resolve();
-        return getDrizzle(db).run(sql `
-      UPDATE tv_library SET status = ${status}, updatedAt = strftime('%s', 'now') WHERE id IN (${sql.join(ids.map((id) => sql `${id}`), sql `, `)})`);
-    },
     touchProgress: (db, id, progress) => getDrizzle(db).run(sql `
       UPDATE tv_library SET lastSeason = ${progress.season}, lastEpisode = ${progress.episode}, updatedAt = strftime('%s', 'now') WHERE id = ${id}`),
-    delete: (db, id) => getDrizzle(db).delete(tvLibrary).where(eq(tvLibrary.id, id)),
-    deleteMany: (db, ids) => {
-        if (ids.length === 0)
-            return Promise.resolve();
-        return getDrizzle(db).delete(tvLibrary).where(inArray(tvLibrary.id, ids));
-    },
 };
 export const TvProgressRepository = {
     getByMedia: (db, mediaId) => getDrizzle(db).all(sql `