ani-web 2.0.7

package/server/dist/github-sync.js

@@ -0,0 +1,342 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.githubSyncService = void 0;
+const logger_1 = __importDefault(require("./logger"));
+const db_utils_1 = require("./utils/db-utils");
+const env_utils_1 = require("./utils/env.utils");
+const config_1 = require("./config");
+const log = logger_1.default.child({ module: 'GitHubSync' });
+const REPO_NAME = 'aniweb-sync-data';
+const DEFAULT_CLIENT_ID = 'Ov23liT1ZtPk7XtN9PZk';
+const GITHUB_SCOPES = ['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() {
+    return process.env.GITHUB_CLIENT_ID || DEFAULT_CLIENT_ID;
+}
+function getSyncFilename() {
+    return config_1.CONFIG.IS_DEV ? 'sync.dev.json' : '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 (0, db_utils_1.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;
+    }
+    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 Promise.resolve().then(() => __importStar(require('./utils/env.utils')));
+                await updateEnvFile({ SYNC_PROVIDER: 'github' });
+                await runSyncSequence(db, 'github');
+                return this.deviceState;
+            }
+            else {
+                // Token exists but is invalid/expired, clear it
+                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 (0, env_utils_1.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 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 ani-web 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 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 (0, env_utils_1.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 ani-web synchronization data.',
+                headers: GITHUB_API_HEADERS,
+            });
+        }
+        return user.login;
+    }
+    async getSyncFile(octokit, owner) {
+        try {
+            const response = await octokit.rest.repos.getContent({
+                owner,
+                repo: REPO_NAME,
+                path: getSyncFilename(),
+                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 exportDatabase(db) {
+        const tables = {};
+        for (const table of SYNC_TABLES) {
+            tables[table] = await getRowsFromAll(db, `SELECT * FROM ${quoteIdentifier(table)}`);
+        }
+        return {
+            version: readVersion({ version: 0, exportedAt: '', tables }),
+            exportedAt: new Date().toISOString(),
+            tables,
+        };
+    }
+    importDatabase(db, payload) {
+        db.serialize(() => {
+            for (const table of SYNC_TABLES) {
+                db.run(`DELETE FROM ${quoteIdentifier(table)}`);
+            }
+            for (const table of SYNC_TABLES) {
+                for (const row of payload.tables[table]) {
+                    const columns = Object.keys(row);
+                    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);
+                }
+            }
+        });
+    }
+}
+exports.githubSyncService = new GitHubSyncService();

package/server/dist/google.js

@@ -0,0 +1,310 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.googleDriveService = exports.GoogleDriveService = void 0;
+const fs_1 = __importDefault(require("fs"));
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const axios_1 = __importDefault(require("axios"));
+const promises_1 = require("stream/promises");
+const logger_1 = __importDefault(require("./logger"));
+const config_1 = require("./config");
+const httpAgent = new http_1.default.Agent({ keepAlive: false });
+const httpsAgent = new https_1.default.Agent({ keepAlive: false });
+httpsAgent.setMaxListeners(100);
+httpAgent.setMaxListeners(100);
+const googleAxios = axios_1.default.create({
+    httpAgent,
+    httpsAgent,
+    timeout: 30000,
+});
+class GoogleDriveService {
+    tokens = {};
+    folderIdCache = new Map();
+    constructor() {
+        if (!config_1.CONFIG.GOOGLE_CLIENT_ID) {
+            logger_1.default.error('GOOGLE_CLIENT_ID is missing from .env!');
+        }
+        this.loadTokens();
+    }
+    loadTokens() {
+        if (fs_1.default.existsSync(config_1.CONFIG.TOKEN_PATH)) {
+            try {
+                this.tokens = JSON.parse(fs_1.default.readFileSync(config_1.CONFIG.TOKEN_PATH, 'utf-8'));
+            }
+            catch (error) {
+                logger_1.default.error({ err: error }, 'Failed to load Google tokens');
+            }
+        }
+    }
+    saveTokens(tokens) {
+        const merged = { ...this.tokens, ...tokens };
+        if (merged.expires_in && !merged.expiry_date) {
+            merged.expiry_date = Date.now() + merged.expires_in * 1000;
+        }
+        this.tokens = merged;
+        try {
+            fs_1.default.writeFileSync(config_1.CONFIG.TOKEN_PATH, JSON.stringify(this.tokens));
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, 'Failed to save refreshed tokens');
+        }
+    }
+    getGoogleClientConfig() {
+        if (!config_1.CONFIG.GOOGLE_CLIENT_ID || !config_1.CONFIG.GOOGLE_CLIENT_SECRET) {
+            throw new Error('Google OAuth credentials are not configured');
+        }
+        return {
+            clientId: config_1.CONFIG.GOOGLE_CLIENT_ID,
+            clientSecret: config_1.CONFIG.GOOGLE_CLIENT_SECRET,
+        };
+    }
+    async refreshAccessToken() {
+        if (!this.tokens.refresh_token) {
+            throw new Error('Missing refresh token');
+        }
+        const { clientId, clientSecret } = this.getGoogleClientConfig();
+        const params = new URLSearchParams({
+            client_id: clientId,
+            client_secret: clientSecret,
+            refresh_token: this.tokens.refresh_token,
+            grant_type: 'refresh_token',
+        });
+        try {
+            const { data } = await googleAxios.post('https://oauth2.googleapis.com/token', params.toString(), {
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            });
+            this.saveTokens(data);
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error) &&
+                (error.response?.status === 400 || error.response?.status === 401)) {
+                logger_1.default.warn('Failed to refresh Google access token. Token may be revoked. Logging out.');
+                await this.logout();
+            }
+            throw error;
+        }
+    }
+    async ensureAccessToken() {
+        const expiresSoon = !this.tokens.expiry_date || Date.now() >= this.tokens.expiry_date - 60_000;
+        if (!this.tokens.access_token || expiresSoon) {
+            await this.refreshAccessToken();
+        }
+    }
+    async googleRequest(config) {
+        await this.ensureAccessToken();
+        try {
+            return await googleAxios.request({
+                ...config,
+                headers: {
+                    Authorization: `Bearer ${this.tokens.access_token}`,
+                    ...(config.headers ?? {}),
+                },
+            });
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error) &&
+                (error.response?.status === 401 || error.response?.status === 403)) {
+                logger_1.default.warn('Google API request failed with auth error. Logging out.');
+                await this.logout();
+            }
+            throw error;
+        }
+    }
+    isAuthenticated() {
+        return !!this.tokens.refresh_token;
+    }
+    getAuthUrl() {
+        const { clientId } = this.getGoogleClientConfig();
+        const url = new URL('https://accounts.google.com/o/oauth2/v2/auth');
+        url.searchParams.set('client_id', clientId);
+        url.searchParams.set('redirect_uri', config_1.CONFIG.GOOGLE_REDIRECT_URI);
+        url.searchParams.set('response_type', 'code');
+        url.searchParams.set('access_type', 'offline');
+        url.searchParams.set('prompt', 'consent');
+        url.searchParams.set('scope', config_1.CONFIG.GOOGLE_SCOPES.join(' '));
+        return url.toString();
+    }
+    async handleCallback(code) {
+        const { clientId, clientSecret } = this.getGoogleClientConfig();
+        const params = new URLSearchParams({
+            code,
+            client_id: clientId,
+            client_secret: clientSecret,
+            redirect_uri: config_1.CONFIG.GOOGLE_REDIRECT_URI,
+            grant_type: 'authorization_code',
+        });
+        const { data } = await googleAxios.post('https://oauth2.googleapis.com/token', params.toString(), {
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        });
+        this.saveTokens(data);
+        return this.tokens;
+    }
+    async getUserProfile() {
+        if (!this.isAuthenticated())
+            return null;
+        try {
+            const res = await this.googleRequest({
+                method: 'GET',
+                url: 'https://www.googleapis.com/oauth2/v2/userinfo',
+            });
+            return res.data;
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, 'Failed to fetch user profile');
+            if (axios_1.default.isAxiosError(error) &&
+                (error.response?.status === 401 || error.response?.status === 403)) {
+                logger_1.default.warn('Google authentication token is invalid or expired. Logging out.');
+                await this.logout();
+            }
+            return null;
+        }
+    }
+    async logout() {
+        if (fs_1.default.existsSync(config_1.CONFIG.TOKEN_PATH)) {
+            fs_1.default.unlinkSync(config_1.CONFIG.TOKEN_PATH);
+        }
+        this.tokens = {};
+        this.folderIdCache.clear();
+    }
+    async ensureFolder(folderName) {
+        if (!this.isAuthenticated())
+            throw new Error('Not authenticated');
+        const cachedId = this.folderIdCache.get(folderName);
+        if (cachedId)
+            return cachedId;
+        const existing = await this.findFile(folderName, undefined, 'application/vnd.google-apps.folder');
+        if (existing) {
+            this.folderIdCache.set(folderName, existing.id);
+            return existing.id;
+        }
+        const fileMetadata = {
+            name: folderName,
+            mimeType: 'application/vnd.google-apps.folder',
+        };
+        try {
+            const res = await this.googleRequest({
+                method: 'POST',
+                url: 'https://www.googleapis.com/drive/v3/files',
+                params: { fields: 'id' },
+                data: fileMetadata,
+                headers: { 'Content-Type': 'application/json' },
+            });
+            const id = res.data.id;
+            this.folderIdCache.set(folderName, id);
+            return id;
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, `Failed to create folder ${folderName}`);
+            throw error;
+        }
+    }
+    async findFile(filename, parentId, mimeType) {
+        if (!this.isAuthenticated())
+            return null;
+        const safeName = filename.replace(/'/g, "\\'");
+        let query = `name = '${safeName}' and trashed = false`;
+        if (parentId) {
+            const safeParentId = parentId.replace(/'/g, "\\'");
+            query += ` and '${safeParentId}' in parents`;
+        }
+        if (mimeType) {
+            const safeMimeType = mimeType.replace(/'/g, "\\'");
+            query += ` and mimeType = '${safeMimeType}'`;
+        }
+        try {
+            const res = await this.googleRequest({
+                method: 'GET',
+                url: 'https://www.googleapis.com/drive/v3/files',
+                params: {
+                    q: query,
+                    fields: 'files(id, name)',
+                    spaces: 'drive',
+                    orderBy: 'createdTime desc',
+                },
+            });
+            if (res.data.files && res.data.files.length > 0) {
+                if (res.data.files.length > 1) {
+                    logger_1.default.warn(`Multiple files found for ${filename}, using the most recent one.`);
+                }
+                return { id: res.data.files[0].id, name: res.data.files[0].name };
+            }
+            return null;
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, `Error while searching for file ${filename}`);
+            throw error;
+        }
+    }
+    async downloadFile(fileId, destPath) {
+        if (!this.isAuthenticated())
+            throw new Error('Not authenticated');
+        const dest = fs_1.default.createWriteStream(destPath);
+        try {
+            const res = await this.googleRequest({
+                method: 'GET',
+                url: `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}`,
+                params: { alt: 'media' },
+                responseType: 'stream',
+            });
+            await (0, promises_1.pipeline)(res.data, dest);
+        }
+        catch (error) {
+            dest.destroy();
+            throw error;
+        }
+    }
+    async uploadFile(filePath, filename, mimeType = 'application/octet-stream', parentId, existingFileId) {
+        if (!this.isAuthenticated())
+            throw new Error('Not authenticated');
+        let targetId = existingFileId;
+        if (!targetId) {
+            const existing = await this.findFile(filename, parentId, mimeType);
+            if (existing)
+                targetId = existing.id;
+        }
+        const media = {
+            mimeType,
+            body: fs_1.default.createReadStream(filePath),
+        };
+        try {
+            if (targetId) {
+                await this.googleRequest({
+                    method: 'PATCH',
+                    url: `https://www.googleapis.com/upload/drive/v3/files/${encodeURIComponent(targetId)}`,
+                    params: { uploadType: 'media' },
+                    data: media.body,
+                    headers: { 'Content-Type': media.mimeType },
+                });
+            }
+            else {
+                const resource = { name: filename };
+                if (parentId) {
+                    resource.parents = [parentId];
+                }
+                const created = await this.googleRequest({
+                    method: 'POST',
+                    url: 'https://www.googleapis.com/drive/v3/files',
+                    params: { fields: 'id' },
+                    data: resource,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+                await this.googleRequest({
+                    method: 'PATCH',
+                    url: `https://www.googleapis.com/upload/drive/v3/files/${encodeURIComponent(created.data.id)}`,
+                    params: { uploadType: 'media' },
+                    data: media.body,
+                    headers: { 'Content-Type': media.mimeType },
+                });
+            }
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, `Failed to upload file ${filename}`);
+            throw error;
+        }
+    }
+}
+exports.GoogleDriveService = GoogleDriveService;
+exports.googleDriveService = new GoogleDriveService();

package/server/dist/logger.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pino_1 = __importDefault(require("pino"));
+const isDevelopment = process.env.NODE_ENV !== 'production';
+const logger = (0, pino_1.default)({
+    level: isDevelopment ? 'debug' : 'info',
+    transport: isDevelopment
+        ? {
+            target: 'pino-pretty',
+            options: {
+                colorize: true,
+                translateTime: 'SYS:standard',
+                ignore: 'pid,hostname',
+            },
+        }
+        : undefined,
+});
+exports.default = logger;