@serifpersia/dango 3.6.7 → 3.6.9

package/server/dist/db/schema-manga.js

@@ -1,31 +0,0 @@
-import { integer, primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-export const mangaLibrary = sqliteTable('manga_library', {
-    id: text('id').notNull(),
-    provider: text('provider').notNull(),
-    mangaId: text('mangaId').notNull(),
-    title: text('title'),
-    cover: text('cover'),
-    status: text('status'),
-    author: text('author'),
-    altTitle: text('altTitle'),
-    contentRating: text('contentRating'),
-    lastChapterId: text('lastChapterId'),
-    lastChapterNumber: text('lastChapterNumber'),
-    lastPage: integer('lastPage'),
-    updatedAt: integer('updatedAt'),
-    anilistId: integer('anilistId'),
-    anilistIdSource: text('anilistIdSource'),
-}, (t) => [primaryKey({ columns: [t.id] })]);
-export const mangaProgress = sqliteTable('manga_progress', {
-    mangaId: text('mangaId').notNull(),
-    chapterId: text('chapterId').notNull(),
-    chapterNumber: text('chapterNumber'),
-    page: integer('page'),
-    pageCount: integer('pageCount'),
-    updatedAt: integer('updatedAt'),
-    title: text('title'),
-    cover: text('cover'),
-    provider: text('provider'),
-    altTitle: text('altTitle'),
-    contentRating: text('contentRating'),
-}, (t) => [primaryKey({ columns: [t.mangaId, t.chapterId] })]);

package/server/dist/db/schema-tv.js

@@ -1,18 +0,0 @@
-import { integer, primaryKey, real, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-export const tvProgress = sqliteTable('tv_progress', {
-    mediaId: text('mediaId').notNull(),
-    season: integer('season').notNull(),
-    episode: integer('episode').notNull(),
-    currentTime: real('currentTime'),
-    duration: real('duration'),
-    updatedAt: integer('updatedAt'),
-    title: text('title'),
-    poster: text('poster'),
-    backdrop: text('backdrop'),
-    year: text('year'),
-    overview: text('overview'),
-    tmdbId: integer('tmdbId'),
-    mediaType: text('mediaType'),
-    adult: integer('adult'),
-    completed: integer('completed'),
-}, (t) => [primaryKey({ columns: [t.mediaId, t.season, t.episode] })]);

package/server/dist/db.js

@@ -1,217 +0,0 @@
-import { DatabaseSync } from 'node:sqlite';
-import { AsyncLocalStorage } from 'node:async_hooks';
-import fs from 'fs';
-import path from 'path';
-import logger from './logger.js';
-const txOwner = new AsyncLocalStorage();
-export class DatabaseWrapper {
-    db;
-    isClosed = false;
-    statementCache = new Map();
-    txDepth = 0;
-    txQueue = Promise.resolve();
-    constructor(_dbPath, db) {
-        this.db = db;
-    }
-    static async create(dbPath) {
-        try {
-            const dir = path.dirname(dbPath);
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
-            }
-            const db = new DatabaseSync(dbPath);
-            return new DatabaseWrapper(dbPath, db);
-        }
-        catch (e) {
-            logger.error({ err: e }, `Failed to initialize database at ${dbPath}`);
-            throw e;
-        }
-    }
-    getClient() {
-        return this.db;
-    }
-    configure(option, value) {
-        if (option === 'busyTimeout') {
-            this.db.exec(`PRAGMA busy_timeout = ${value}`);
-        }
-    }
-    serialize(cb) {
-        const outer = this.txDepth === 0;
-        const level = this.txDepth;
-        this.run(outer ? 'BEGIN IMMEDIATE' : `SAVEPOINT dango_sp_${level}`);
-        this.txDepth = level + 1;
-        try {
-            txOwner.run(this, cb);
-        }
-        catch (e) {
-            this.txDepth = level;
-            try {
-                this.run(outer ? 'ROLLBACK' : `ROLLBACK TO SAVEPOINT dango_sp_${level}`);
-            }
-            catch {
-                // ignore
-            }
-            throw e;
-        }
-        this.txDepth = level;
-        this.run(outer ? 'COMMIT' : `RELEASE SAVEPOINT dango_sp_${level}`);
-    }
-    acquireTxQueue() {
-        const prev = this.txQueue;
-        let release;
-        const current = new Promise((res) => {
-            release = res;
-        });
-        this.txQueue = prev.then(() => current);
-        return prev.then(() => release);
-    }
-    async transact(fn) {
-        if (txOwner.getStore() === this) {
-            const level = this.txDepth;
-            this.run(`SAVEPOINT dango_sp_${level}`);
-            this.txDepth = level + 1;
-            try {
-                await fn(this);
-            }
-            catch (e) {
-                this.txDepth = level;
-                try {
-                    this.run(`ROLLBACK TO SAVEPOINT dango_sp_${level}`);
-                }
-                catch {
-                    // ignore
-                }
-                throw e;
-            }
-            this.txDepth = level;
-            this.run(`RELEASE SAVEPOINT dango_sp_${level}`);
-            return;
-        }
-        const release = await this.acquireTxQueue();
-        try {
-            await txOwner.run(this, async () => {
-                this.run('BEGIN IMMEDIATE');
-                this.txDepth = 1;
-                try {
-                    await fn(this);
-                }
-                catch (e) {
-                    this.txDepth = 0;
-                    try {
-                        this.run('ROLLBACK');
-                    }
-                    catch {
-                        // ignore
-                    }
-                    throw e;
-                }
-                this.txDepth = 0;
-                this.run('COMMIT');
-            });
-        }
-        finally {
-            release();
-        }
-    }
-    close(cb) {
-        if (this.isClosed) {
-            if (cb)
-                cb(null);
-            return;
-        }
-        try {
-            this.isClosed = true;
-            this.statementCache.clear();
-            this.db.close();
-            if (cb)
-                cb(null);
-        }
-        catch (e) {
-            logger.error({ err: e }, 'Error during database close');
-            if (cb)
-                cb(e);
-        }
-    }
-    isClosedCheck() {
-        return this.isClosed;
-    }
-    getPreparedStatement(query) {
-        let stmt = this.statementCache.get(query);
-        if (!stmt) {
-            if (this.statementCache.size > 100) {
-                this.statementCache.clear();
-            }
-            stmt = this.db.prepare(query);
-            this.statementCache.set(query, stmt);
-        }
-        return stmt;
-    }
-    run(query, params = []) {
-        if (this.isClosed) {
-            throw new Error('Database is closed');
-        }
-        const stmt = this.getPreparedStatement(query);
-        if (params.length > 0) {
-            stmt.run(...params);
-        }
-        else {
-            stmt.run();
-        }
-    }
-    get(query, params = []) {
-        if (this.isClosed) {
-            throw new Error('Database is closed');
-        }
-        const stmt = this.getPreparedStatement(query);
-        if (params.length > 0) {
-            return stmt.get(...params);
-        }
-        return stmt.get();
-    }
-    all(query, params = []) {
-        if (this.isClosed) {
-            throw new Error('Database is closed');
-        }
-        const stmt = this.getPreparedStatement(query);
-        if (params.length > 0) {
-            return stmt.all(...params);
-        }
-        return stmt.all();
-    }
-    prepare(query) {
-        const stmt = this.getPreparedStatement(query);
-        return {
-            run: (...args) => {
-                stmt.run(...args);
-            },
-            all: () => {
-                return stmt.all();
-            },
-            get: () => {
-                return stmt.get();
-            },
-            finalize: () => { },
-        };
-    }
-    backup(backupPath) {
-        try {
-            if (fs.existsSync(backupPath)) {
-                fs.rmSync(backupPath, { force: true });
-            }
-            this.db.exec(`VACUUM INTO '${backupPath}'`);
-        }
-        catch (e) {
-            logger.error({ err: e, backupPath }, 'Database backup failed via VACUUM INTO');
-            throw e;
-        }
-    }
-    checkpoint() {
-        try {
-            this.db.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-        }
-        catch (e) {
-            logger.error({ err: e }, 'Database WAL checkpoint failed');
-            throw e;
-        }
-    }
-}

package/server/dist/discord-gateway.js

@@ -1,385 +0,0 @@
-import WebSocket from 'ws';
-import logger from './logger.js';
-import { CONFIG } from './config.js';
-import dotenv from 'dotenv';
-const log = logger.child({ module: 'DiscordGateway' });
-class DiscordGatewayService {
-    gateway = null;
-    heartbeat = null;
-    token = null;
-    reconnectTimeout = null;
-    lastActivity = null;
-    isEnabled = false;
-    RECONNECT_DELAY = 15000;
-    externalAssetCache = new Map();
-    setEnabled(enabled) {
-        this.isEnabled = enabled;
-        if (enabled) {
-            this.loadToken();
-            this.connect();
-        }
-        else {
-            this.disconnect();
-        }
-    }
-    get serviceEnabled() {
-        return this.isEnabled && !!this.token && this.token.length > 30;
-    }
-    hasToken() {
-        return !!this.token && this.token.length > 30;
-    }
-    loadToken() {
-        this.token = process.env.DISCORD_GATEWAY_TOKEN || null;
-    }
-    reloadToken() {
-        dotenv.config({ path: CONFIG.ENV_PATH, override: true });
-        this.loadToken();
-        if (this.serviceEnabled) {
-            this.disconnect();
-            this.connect();
-        }
-    }
-    async getExternalAsset(url) {
-        if (!CONFIG.DISCORD_CLIENT_ID || !this.token)
-            return null;
-        const cached = this.externalAssetCache.get(url);
-        if (cached)
-            return cached;
-        try {
-            const res = await fetch(`https://discord.com/api/v9/applications/${CONFIG.DISCORD_CLIENT_ID}/external-assets`, {
-                method: 'POST',
-                headers: {
-                    Authorization: this.token,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({ urls: [url] }),
-            });
-            const text = await res.text();
-            if (!res.ok) {
-                log.warn(`external-assets proxy failed ${res.status}: ${text.slice(0, 200)}`);
-                return null;
-            }
-            const data = JSON.parse(text);
-            if (!data[0]?.external_asset_path)
-                return null;
-            const mp = `mp:${data[0].external_asset_path}`;
-            this.externalAssetCache.set(url, mp);
-            return mp;
-        }
-        catch (err) {
-            log.warn({ err }, 'external-assets proxy error');
-            return null;
-        }
-    }
-    resolveImageUrl(data) {
-        const isSafeUrl = (url) => {
-            if (!url.startsWith('https://'))
-                return false;
-            if (url.includes('localhost') || url.includes('127.0.0.1'))
-                return false;
-            if (url.includes('s4.anilist.co') || url.includes('anilistcdn'))
-                return true;
-            const blocked = [
-                'youtube-anime.com',
-                'animepahe',
-                'animeya.cc',
-                'gogocdn.net',
-                'weeabo0.xyz',
-                'japaneseasmr.com',
-            ];
-            return !blocked.some((d) => url.includes(d));
-        };
-        let thumb = data.thumbnail;
-        if (thumb && thumb.includes('/api/image-proxy')) {
-            const m = thumb.match(/url=([^&]+)/);
-            if (m) {
-                try {
-                    thumb = decodeURIComponent(m[1]);
-                }
-                catch (_e) {
-                    void _e;
-                }
-            }
-        }
-        if (thumb && data.providerName !== 'AnimePahe' && isSafeUrl(thumb))
-            return thumb;
-        if (data.thumbnails) {
-            const safe = data.thumbnails.find((t) => t && (t.includes('s4.anilist.co') || t.includes('anilistcdn')));
-            if (safe)
-                return safe;
-        }
-        if (thumb && isSafeUrl(thumb))
-            return thumb;
-        return null;
-    }
-    async updatePresence(data) {
-        this.lastActivity = data;
-        if (!this.isEnabled || !this.gateway || this.gateway.readyState !== WebSocket.OPEN)
-            return;
-        const name = 'dango';
-        const details = data.title;
-        const state = data.stateLine
-            ? data.stateLine
-            : `Episode ${data.episode}${data.totalEpisodes ? `/${data.totalEpisodes}` : ''}`;
-        const type = data.providerName === 'ASMR' || data.providerName === 'Radio' || data.providerName === 'Music'
-            ? 2
-            : 3;
-        const imageUrl = this.resolveImageUrl(data);
-        let assets;
-        if (imageUrl) {
-            if (CONFIG.DISCORD_CLIENT_ID) {
-                const proxied = await this.getExternalAsset(imageUrl);
-                if (proxied) {
-                    assets = {
-                        large_image: proxied,
-                        large_text: data.title.slice(0, 128),
-                        small_image: 'small',
-                        small_text: 'dango',
-                    };
-                }
-                else {
-                    assets = { large_image: 'logo', large_text: data.title.slice(0, 128) };
-                }
-            }
-        }
-        else if (CONFIG.DISCORD_CLIENT_ID) {
-            assets = { large_image: 'logo', large_text: data.title.slice(0, 128) };
-        }
-        const presence = {
-            since: null,
-            activities: [
-                {
-                    name,
-                    type,
-                    state: data.isPlaying ? state : `${state} (Paused)`,
-                    details,
-                    ...(CONFIG.DISCORD_CLIENT_ID ? { application_id: CONFIG.DISCORD_CLIENT_ID } : {}),
-                    ...(assets ? { assets } : {}),
-                    buttons: ['Learn More'],
-                    metadata: { button_urls: ['https://github.com/serifpersia/dango'] },
-                    status_display_type: 2,
-                },
-            ],
-            status: 'online',
-            afk: false,
-        };
-        const nowMs = Date.now();
-        if (data.isPlaying) {
-            if (data.currentTime && data.currentTime > 0) {
-                presence.since = nowMs - Math.round(data.currentTime * 1000);
-            }
-            if (data.duration && data.duration > data.currentTime) {
-                presence.activities[0].timestamps = {
-                    start: nowMs - Math.round(data.currentTime * 1000),
-                    end: nowMs + Math.round((data.duration - data.currentTime) * 1000),
-                };
-            }
-        }
-        try {
-            this.gateway.send(JSON.stringify({ op: 3, d: presence }));
-        }
-        catch (err) {
-            log.error({ err }, 'Failed to send gateway presence update');
-        }
-    }
-    setIdleStatus(page) {
-        if (!this.isEnabled || !this.gateway || this.gateway.readyState !== WebSocket.OPEN)
-            return;
-        const pageLabels = {
-            home: { details: 'Home', state: 'Browsing anime' },
-            search: { details: 'Search', state: 'Exploring titles...' },
-            watchlist: { details: 'Watchlist', state: 'Reviewing the watchlist' },
-            anime: { details: 'Anime Info', state: 'Reading show details' },
-            insights: { details: 'Insights', state: 'Reviewing stats' },
-            settings: { details: 'Settings', state: 'Tweaking preferences' },
-            trackers: { details: 'Trackers', state: 'Syncing watchlists' },
-            map: { details: 'Map', state: 'Exploring the global user map' },
-            asmr: { details: 'ASMR', state: 'Browsing ASMR works' },
-            radio: { details: 'Radio', state: 'Browsing radio stations' },
-            music: { details: 'Music', state: 'Browsing music' },
-            tv: { details: 'TV', state: 'Browsing movies & shows' },
-            manga: { details: 'Manga', state: 'Browsing manga' },
-        };
-        const label = pageLabels[page] ?? { details: 'dango', state: 'Idle' };
-        try {
-            this.gateway.send(JSON.stringify({
-                op: 3,
-                d: {
-                    since: null,
-                    activities: [
-                        {
-                            name: 'dango',
-                            type: page === 'asmr' || page === 'radio' || page === 'music' ? 2 : 3,
-                            state: label.state,
-                            details: label.details,
-                            ...(CONFIG.DISCORD_CLIENT_ID ? { application_id: CONFIG.DISCORD_CLIENT_ID } : {}),
-                            ...(CONFIG.DISCORD_CLIENT_ID
-                                ? { assets: { large_image: 'logo', large_text: 'dango' } }
-                                : {}),
-                            buttons: ['Learn More'],
-                            metadata: { button_urls: ['https://github.com/serifpersia/dango'] },
-                            status_display_type: 2,
-                        },
-                    ],
-                    status: 'online',
-                    afk: false,
-                },
-            }));
-        }
-        catch (err) {
-            log.error({ err }, 'Failed to send gateway idle status');
-        }
-    }
-    clearPresence() {
-        if (!this.isEnabled)
-            return;
-        if (this.gateway && this.gateway.readyState === WebSocket.OPEN) {
-            try {
-                this.gateway.send(JSON.stringify({
-                    op: 3,
-                    d: { since: null, activities: [], status: 'online', afk: false },
-                }));
-            }
-            catch {
-                // ignore
-            }
-        }
-        this.lastActivity = null;
-    }
-    shutdown() {
-        this.isEnabled = false;
-        this.token = null;
-        this.disconnect();
-    }
-    disconnect() {
-        if (this.reconnectTimeout) {
-            clearTimeout(this.reconnectTimeout);
-            this.reconnectTimeout = null;
-        }
-        if (this.gateway) {
-            try {
-                if (this.gateway.readyState === WebSocket.OPEN) {
-                    this.gateway.send(JSON.stringify({
-                        op: 3,
-                        d: { since: null, activities: [], status: 'online', afk: false },
-                    }));
-                }
-                this.gateway.close();
-            }
-            catch {
-                // ignore
-            }
-            this.gateway = null;
-        }
-        if (this.heartbeat) {
-            clearInterval(this.heartbeat);
-            this.heartbeat = null;
-        }
-    }
-    connect() {
-        if (!this.isEnabled || !this.token || this.gateway)
-            return;
-        const wsUrl = 'wss://gateway.discord.gg/?encoding=json&v=10';
-        log.debug('Connecting Discord gateway');
-        this.gateway = new WebSocket(wsUrl);
-        let heartbeatInterval = 41250;
-        this.gateway.on('message', (data) => {
-            try {
-                const msg = JSON.parse(data.toString());
-                if (msg.op === 10) {
-                    heartbeatInterval = msg.d.heartbeat_interval;
-                    this.heartbeat = setInterval(() => {
-                        try {
-                            if (this.gateway && this.gateway.readyState === WebSocket.OPEN) {
-                                this.gateway.send(JSON.stringify({ op: 1, d: null }));
-                            }
-                        }
-                        catch {
-                            // ignore
-                        }
-                    }, heartbeatInterval);
-                    const identify = {
-                        op: 2,
-                        d: {
-                            token: this.token,
-                            capabilities: 1021,
-                            client_state: {
-                                guild_hashes: {},
-                                highest_last_message_id: '0',
-                                private_channels_version: '0',
-                                read_state_version: 0,
-                                user_guild_settings_version: -1,
-                                user_settings_version: -1,
-                            },
-                            compress: false,
-                            presence: {
-                                since: null,
-                                activities: [],
-                                status: 'online',
-                                afk: false,
-                            },
-                            properties: {
-                                os: 'Windows',
-                                os_version: '10.0.19044',
-                                os_arch: 'x64',
-                                browser: 'Discord Client',
-                                client_version: '0.0.20',
-                                client_build_number: 152131,
-                                client_event_source: null,
-                                release_channel: 'stable',
-                                system_locale: 'en-US',
-                            },
-                        },
-                    };
-                    if (this.gateway) {
-                        this.gateway.send(JSON.stringify(identify));
-                    }
-                }
-                else if (msg.op === 11) {
-                    // ignore
-                }
-                else if (msg.op === 0) {
-                    if (msg.t === 'READY') {
-                        log.info(`Gateway READY as ${msg.d.user?.username || 'unknown'}`);
-                        if (this.lastActivity) {
-                            void this.updatePresence(this.lastActivity).catch((err) => log.warn({ err }, 'failed to restore presence after READY'));
-                        }
-                    }
-                }
-                else if (msg.op === 7) {
-                    log.warn('Gateway reconnect requested by Discord');
-                    this.handleDisconnect();
-                }
-                else if (msg.op === 9) {
-                    log.warn('Gateway invalid session, reconnecting...');
-                    this.handleDisconnect();
-                }
-            }
-            catch (err) {
-                log.debug({ err }, 'Gateway message parse error');
-            }
-        });
-        this.gateway.on('close', (code, reason) => {
-            log.warn(`Gateway closed ${code} ${reason.toString().slice(0, 100)}`);
-            this.handleDisconnect();
-        });
-        this.gateway.on('error', (err) => {
-            log.error(err, 'Gateway WebSocket error');
-            this.handleDisconnect();
-        });
-    }
-    handleDisconnect() {
-        if (this.heartbeat) {
-            clearInterval(this.heartbeat);
-            this.heartbeat = null;
-        }
-        this.gateway = null;
-        if (this.isEnabled && this.token) {
-            this.reconnectTimeout = setTimeout(() => {
-                this.reconnectTimeout = null;
-                this.connect();
-            }, this.RECONNECT_DELAY);
-        }
-    }
-}
-export const discordGatewayService = new DiscordGatewayService();