@serifpersia/dango 3.3.4

package/server/dist/github-sync.js

@@ -0,0 +1,512 @@
+import logger from './logger.js';
+import path from 'path';
+import { dbAll, dbGet } from './utils/db-utils.js';
+import { isTempSyncRow } from './lib/temp-ids.js';
+import { updateEnvFile } from './utils/env.utils.js';
+import { CONFIG } from './config.js';
+import { SHIPPED_DEFAULTS } from './shipped-defaults.js';
+import { exportTables, importTables, MANGA_SYNC_TABLES, TV_SYNC_TABLES, ASMR_SYNC_TABLES, normalizePayload as normalizeGenericPayload, readPayloadVersion, } from './sync-payload.js';
+const log = logger.child({ module: 'GitHubSync' });
+const REPO_NAME = 'dango-sync-data';
+const LEGACY_REPO_NAME = 'aniweb-sync-data';
+const GITHUB_SCOPES = ['repo', 'delete_repo'];
+const GITHUB_API_HEADERS = {
+    accept: 'application/vnd.github+json',
+    'x-github-api-version': '2026-03-10',
+};
+const SYNC_TABLES = [
+    'watchlist',
+    'watched_episodes',
+    'queue',
+    'settings',
+    'shows_meta',
+    'sync_metadata',
+    'dismissed_notifications',
+    'discovered_notifications',
+];
+const nativeImport = new Function('specifier', 'return import(specifier)');
+function getGitHubClientId() {
+    const id = process.env.GITHUB_CLIENT_ID || SHIPPED_DEFAULTS.GITHUB_CLIENT_ID || '';
+    if (!id) {
+        throw new Error('GITHUB_CLIENT_ID is not configured');
+    }
+    return id;
+}
+function getSyncFilename() {
+    return CONFIG.IS_DEV ? 'sync.dev.json' : 'sync.json';
+}
+function getMangaSyncFilename() {
+    return CONFIG.IS_DEV ? 'manga.sync.dev.json' : 'manga.sync.json';
+}
+function getTvSyncFilename() {
+    return CONFIG.IS_DEV ? 'tv.sync.dev.json' : 'tv.sync.json';
+}
+function getAsmrSyncFilename() {
+    return CONFIG.IS_DEV ? 'asmr.sync.dev.json' : 'asmr.sync.json';
+}
+async function loadOctokit(token) {
+    const { Octokit } = await nativeImport('@octokit/rest');
+    return new Octokit({
+        auth: token,
+        request: {
+            headers: GITHUB_API_HEADERS,
+        },
+    });
+}
+function getErrorStatus(error) {
+    if (typeof error === 'object' && error && 'status' in error) {
+        return Number(error.status);
+    }
+    return undefined;
+}
+function quoteIdentifier(identifier) {
+    return `"${identifier.replace(/"/g, '""')}"`;
+}
+function getRowsFromAll(db, sql) {
+    return dbAll(db, sql);
+}
+function readVersion(payload) {
+    const versionRow = payload.tables.sync_metadata.find((row) => row.key === 'db_version');
+    const value = versionRow?.value;
+    return typeof value === 'number' ? value : Number(value || payload.version || 0);
+}
+function normalizePayload(input) {
+    if (!input || typeof input !== 'object' || !('tables' in input)) {
+        throw new Error('Invalid GitHub sync payload.');
+    }
+    const payload = input;
+    for (const table of SYNC_TABLES) {
+        if (!Array.isArray(payload.tables?.[table])) {
+            throw new Error(`Invalid GitHub sync payload: missing ${table}.`);
+        }
+    }
+    return payload;
+}
+class GitHubSyncService {
+    deviceState = { status: 'idle' };
+    devicePromise = null;
+    isAuthenticated() {
+        return !!process.env.GITHUB_TOKEN;
+    }
+    async migrateFromAniWebSync() {
+        if (!this.isAuthenticated())
+            return;
+        try {
+            const octokit = await this.getOctokit();
+            const { data: user } = await octokit.rest.users.getAuthenticated({
+                headers: GITHUB_API_HEADERS,
+            });
+            try {
+                await octokit.rest.repos.get({
+                    owner: user.login,
+                    repo: LEGACY_REPO_NAME,
+                    headers: GITHUB_API_HEADERS,
+                });
+            }
+            catch (err) {
+                if (getErrorStatus(err) === 404) {
+                    log.info('No legacy aniweb-sync-data repo found. Skipping migration.');
+                    return;
+                }
+                throw err;
+            }
+            log.info('Found legacy aniweb-sync-data repo. Renaming to dango-sync-data...');
+            const existingNew = await octokit.rest.repos
+                .get({
+                owner: user.login,
+                repo: REPO_NAME,
+                headers: GITHUB_API_HEADERS,
+            })
+                .catch(() => null);
+            if (existingNew) {
+                log.info('dango-sync-data repo already exists. Deleting legacy repo.');
+                await octokit.rest.repos.delete({
+                    owner: user.login,
+                    repo: LEGACY_REPO_NAME,
+                    headers: GITHUB_API_HEADERS,
+                });
+                log.info('Deleted legacy aniweb-sync-data repo.');
+                return;
+            }
+            await octokit.rest.repos.update({
+                owner: user.login,
+                repo: LEGACY_REPO_NAME,
+                name: REPO_NAME,
+                description: 'Private dango synchronization data.',
+                headers: GITHUB_API_HEADERS,
+            });
+            log.info('Renamed aniweb-sync-data to dango-sync-data.');
+        }
+        catch (err) {
+            log.error({ err }, 'GitHub sync migration failed');
+        }
+    }
+    getDeviceState() {
+        return this.deviceState;
+    }
+    async startDeviceAuth(db, runSyncSequence) {
+        if (this.isAuthenticated()) {
+            const user = await this.getUserProfile();
+            if (user) {
+                this.deviceState = {
+                    status: 'success',
+                    user: user,
+                };
+                const { updateEnvFile } = await import('./utils/env.utils.js');
+                await updateEnvFile({ SYNC_PROVIDER: 'github' });
+                await runSyncSequence(db, 'github');
+                return this.deviceState;
+            }
+            else {
+                log.warn('Saved GitHub token is invalid or expired. Clearing for new auth.');
+                await this.logout();
+            }
+        }
+        if (this.deviceState.status === 'pending') {
+            return this.deviceState;
+        }
+        this.deviceState = { status: 'pending' };
+        let resolveVerification;
+        const verificationReady = new Promise((resolve) => {
+            resolveVerification = resolve;
+        });
+        this.devicePromise = this.runDeviceAuth(db, runSyncSequence, resolveVerification);
+        await verificationReady;
+        return this.deviceState;
+    }
+    async getUserProfile() {
+        if (!process.env.GITHUB_TOKEN)
+            return null;
+        try {
+            const octokit = await loadOctokit(process.env.GITHUB_TOKEN);
+            const { data } = await octokit.rest.users.getAuthenticated({
+                headers: GITHUB_API_HEADERS,
+            });
+            return {
+                login: data.login,
+                name: data.name,
+                avatarUrl: data.avatar_url,
+            };
+        }
+        catch (err) {
+            if (getErrorStatus(err) === 401) {
+                log.warn('GitHub token is invalid or expired. Logging out.');
+                await this.logout();
+            }
+            return null;
+        }
+    }
+    async logout() {
+        await updateEnvFile({ GITHUB_TOKEN: '' });
+        delete process.env.GITHUB_TOKEN;
+        this.deviceState = { status: 'idle' };
+    }
+    async getRemoteVersion() {
+        const payload = await this.fetchSyncPayload();
+        return payload ? readVersion(payload) : 0;
+    }
+    async getMangaRemoteVersion() {
+        const payload = await this.fetchMangaSyncPayload();
+        return payload ? readPayloadVersion(payload) : 0;
+    }
+    async getTvRemoteVersion() {
+        const payload = await this.fetchTvSyncPayload();
+        return payload ? readPayloadVersion(payload) : 0;
+    }
+    async getAsmrRemoteVersion() {
+        const payload = await this.fetchAsmrSyncPayload();
+        return payload ? readPayloadVersion(payload) : 0;
+    }
+    async syncUp(db) {
+        const payload = await this.exportDatabase(db);
+        const octokit = await this.getOctokit();
+        const owner = await this.ensureRepo(octokit);
+        const existing = await this.getSyncFile(octokit, owner);
+        const content = Buffer.from(JSON.stringify(payload, null, 2), 'utf8').toString('base64');
+        await octokit.rest.repos.createOrUpdateFileContents({
+            owner,
+            repo: REPO_NAME,
+            path: getSyncFilename(),
+            message: `Sync dango data v${payload.version}`,
+            content,
+            sha: existing?.sha,
+            headers: GITHUB_API_HEADERS,
+        });
+    }
+    async syncDown(db) {
+        const payload = await this.fetchSyncPayload();
+        if (!payload) {
+            return 0;
+        }
+        this.importDatabase(db, payload);
+        return readVersion(payload);
+    }
+    async syncMangaUp(db) {
+        const payload = exportTables(db, MANGA_SYNC_TABLES);
+        const octokit = await this.getOctokit();
+        const owner = await this.ensureRepo(octokit);
+        const existing = await this.getSyncFile(octokit, owner, getMangaSyncFilename());
+        const content = Buffer.from(JSON.stringify(payload, null, 2), 'utf8').toString('base64');
+        await octokit.rest.repos.createOrUpdateFileContents({
+            owner,
+            repo: REPO_NAME,
+            path: getMangaSyncFilename(),
+            message: `Sync dango manga data v${payload.version}`,
+            content,
+            sha: existing?.sha,
+            headers: GITHUB_API_HEADERS,
+        });
+    }
+    async syncMangaDown(db) {
+        const payload = await this.fetchMangaSyncPayload();
+        if (!payload) {
+            return 0;
+        }
+        importTables(db, MANGA_SYNC_TABLES, payload, {
+            libraryTables: ['manga_library', 'manga_progress'],
+            backupName: 'pre-sync-manga-backup.db',
+        });
+        return readPayloadVersion(payload);
+    }
+    async syncTvUp(db) {
+        const payload = exportTables(db, TV_SYNC_TABLES);
+        const octokit = await this.getOctokit();
+        const owner = await this.ensureRepo(octokit);
+        const existing = await this.getSyncFile(octokit, owner, getTvSyncFilename());
+        const content = Buffer.from(JSON.stringify(payload, null, 2), 'utf8').toString('base64');
+        await octokit.rest.repos.createOrUpdateFileContents({
+            owner,
+            repo: REPO_NAME,
+            path: getTvSyncFilename(),
+            message: `Sync dango TV data v${payload.version}`,
+            content,
+            sha: existing?.sha,
+            headers: GITHUB_API_HEADERS,
+        });
+    }
+    async syncTvDown(db) {
+        const payload = await this.fetchTvSyncPayload();
+        if (!payload) {
+            return 0;
+        }
+        importTables(db, TV_SYNC_TABLES, payload, {
+            libraryTables: ['tv_library', 'tv_progress'],
+            backupName: 'pre-sync-tv-backup.db',
+        });
+        return readPayloadVersion(payload);
+    }
+    async syncAsmrUp(db) {
+        const payload = exportTables(db, ASMR_SYNC_TABLES);
+        const octokit = await this.getOctokit();
+        const owner = await this.ensureRepo(octokit);
+        const existing = await this.getSyncFile(octokit, owner, getAsmrSyncFilename());
+        const content = Buffer.from(JSON.stringify(payload, null, 2), 'utf8').toString('base64');
+        await octokit.rest.repos.createOrUpdateFileContents({
+            owner,
+            repo: REPO_NAME,
+            path: getAsmrSyncFilename(),
+            message: `Sync dango ASMR data v${payload.version}`,
+            content,
+            sha: existing?.sha,
+            headers: GITHUB_API_HEADERS,
+        });
+    }
+    async syncAsmrDown(db) {
+        const payload = await this.fetchAsmrSyncPayload();
+        if (!payload) {
+            return 0;
+        }
+        importTables(db, ASMR_SYNC_TABLES, payload, {
+            libraryTables: ['asmr_library', 'asmr_progress'],
+            backupName: 'pre-sync-asmr-backup.db',
+        });
+        return readPayloadVersion(payload);
+    }
+    async runDeviceAuth(db, runSyncSequence, resolveVerification) {
+        try {
+            const { createOAuthDeviceAuth } = await nativeImport('@octokit/auth-oauth-device');
+            const auth = createOAuthDeviceAuth({
+                clientId: getGitHubClientId(),
+                scopes: GITHUB_SCOPES,
+                onVerification: (verification) => {
+                    this.deviceState = {
+                        status: 'pending',
+                        verification: {
+                            user_code: verification.user_code,
+                            verification_uri: verification.verification_uri,
+                            expires_in: verification.expires_in,
+                            interval: verification.interval,
+                        },
+                    };
+                    resolveVerification();
+                },
+            });
+            const authentication = await auth({ type: 'oauth' });
+            await updateEnvFile({ GITHUB_TOKEN: authentication.token, SYNC_PROVIDER: 'github' });
+            process.env.GITHUB_TOKEN = authentication.token;
+            const user = await this.getUserProfile();
+            this.deviceState = {
+                status: 'success',
+                user: user || undefined,
+            };
+            try {
+                await runSyncSequence(db, 'github');
+            }
+            catch (err) {
+                log.error({ err }, 'Post-GitHub-login sync failed');
+            }
+        }
+        catch (err) {
+            this.deviceState = {
+                status: 'error',
+                error: err instanceof Error ? err.message : 'GitHub device authentication failed.',
+            };
+            resolveVerification();
+            log.error({ err }, 'GitHub device authentication failed');
+        }
+        finally {
+            this.devicePromise = null;
+        }
+    }
+    async getOctokit() {
+        if (!process.env.GITHUB_TOKEN) {
+            throw new Error('GitHub token is not configured.');
+        }
+        return loadOctokit(process.env.GITHUB_TOKEN);
+    }
+    async ensureRepo(octokit) {
+        const { data: user } = await octokit.rest.users.getAuthenticated({
+            headers: GITHUB_API_HEADERS,
+        });
+        try {
+            await octokit.rest.repos.get({
+                owner: user.login,
+                repo: REPO_NAME,
+                headers: GITHUB_API_HEADERS,
+            });
+        }
+        catch (err) {
+            if (getErrorStatus(err) !== 404) {
+                throw err;
+            }
+            await octokit.rest.repos.createForAuthenticatedUser({
+                name: REPO_NAME,
+                private: true,
+                auto_init: true,
+                description: 'Private dango synchronization data.',
+                headers: GITHUB_API_HEADERS,
+            });
+        }
+        return user.login;
+    }
+    async getSyncFile(octokit, owner, filePath = getSyncFilename()) {
+        try {
+            const response = await octokit.rest.repos.getContent({
+                owner,
+                repo: REPO_NAME,
+                path: filePath,
+                headers: GITHUB_API_HEADERS,
+            });
+            const data = response.data;
+            if (data.type !== 'file' || !data.content || !data.sha) {
+                return null;
+            }
+            return {
+                content: Buffer.from(data.content, 'base64').toString('utf8'),
+                sha: data.sha,
+            };
+        }
+        catch (err) {
+            if (getErrorStatus(err) === 404) {
+                return null;
+            }
+            throw err;
+        }
+    }
+    async fetchSyncPayload() {
+        const octokit = await this.getOctokit();
+        const owner = await this.ensureRepo(octokit);
+        const file = await this.getSyncFile(octokit, owner);
+        if (!file) {
+            return null;
+        }
+        return normalizePayload(JSON.parse(file.content));
+    }
+    async fetchMangaSyncPayload() {
+        const octokit = await this.getOctokit();
+        const owner = await this.ensureRepo(octokit);
+        const file = await this.getSyncFile(octokit, owner, getMangaSyncFilename());
+        if (!file) {
+            return null;
+        }
+        return normalizeGenericPayload(JSON.parse(file.content), MANGA_SYNC_TABLES, 'GitHub manga');
+    }
+    async fetchTvSyncPayload() {
+        const octokit = await this.getOctokit();
+        const owner = await this.ensureRepo(octokit);
+        const file = await this.getSyncFile(octokit, owner, getTvSyncFilename());
+        if (!file) {
+            return null;
+        }
+        return normalizeGenericPayload(JSON.parse(file.content), TV_SYNC_TABLES, 'GitHub TV');
+    }
+    async fetchAsmrSyncPayload() {
+        const octokit = await this.getOctokit();
+        const owner = await this.ensureRepo(octokit);
+        const file = await this.getSyncFile(octokit, owner, getAsmrSyncFilename());
+        if (!file) {
+            return null;
+        }
+        return normalizeGenericPayload(JSON.parse(file.content), ASMR_SYNC_TABLES, 'GitHub ASMR');
+    }
+    async exportDatabase(db) {
+        const tables = {};
+        for (const table of SYNC_TABLES) {
+            const rows = await getRowsFromAll(db, `SELECT * FROM ${quoteIdentifier(table)}`);
+            tables[table] = rows.filter((row) => !isTempSyncRow(row));
+        }
+        return {
+            version: readVersion({ version: 0, exportedAt: '', tables }),
+            exportedAt: new Date().toISOString(),
+            tables,
+        };
+    }
+    importDatabase(db, payload) {
+        const remoteLibraryRows = (payload.tables.watchlist?.length ?? 0) + (payload.tables.watched_episodes?.length ?? 0);
+        const localLibraryRows = dbGet(db, 'SELECT (SELECT COUNT(*) FROM watchlist) + (SELECT COUNT(*) FROM watched_episodes) AS n')?.n ?? 0;
+        if (remoteLibraryRows === 0 && localLibraryRows > 0) {
+            throw new Error('Sync down refused: remote library is empty while local library has data');
+        }
+        try {
+            db.backup(path.join(CONFIG.ROOT, 'pre-sync-backup.db'));
+        }
+        catch (err) {
+            log.warn({ err }, 'Pre-sync backup failed, continuing without backup');
+        }
+        const localColumns = new Map();
+        for (const table of SYNC_TABLES) {
+            const cols = db.all(`PRAGMA table_info("${table}")`);
+            localColumns.set(table, new Set(cols.map((c) => c.name)));
+        }
+        db.serialize(() => {
+            for (const table of SYNC_TABLES) {
+                db.run(`DELETE FROM ${quoteIdentifier(table)}`);
+            }
+            for (const table of SYNC_TABLES) {
+                const known = localColumns.get(table);
+                for (const row of payload.tables[table]) {
+                    if (isTempSyncRow(row))
+                        continue;
+                    const columns = Object.keys(row).filter((c) => known?.has(c));
+                    if (columns.length === 0)
+                        continue;
+                    const columnSql = columns.map(quoteIdentifier).join(', ');
+                    const placeholders = columns.map(() => '?').join(', ');
+                    const values = columns.map((column) => row[column]);
+                    db.run(`INSERT INTO ${quoteIdentifier(table)} (${columnSql}) VALUES (${placeholders})`, values);
+                }
+            }
+        });
+    }
+}
+export const githubSyncService = new GitHubSyncService();