@serifpersia/dango 3.3.4

package/server/dist/google.js

@@ -0,0 +1,748 @@
+import fs from 'fs';
+import path from 'path';
+import { Readable } from 'stream';
+import { pipeline } from 'stream/promises';
+import logger from './logger.js';
+import { CONFIG } from './config.js';
+import { dbAll, dbGet } from './utils/db-utils.js';
+import { isTempSyncRow } from './lib/temp-ids.js';
+import { fetchWithRetry, HttpError, decodeMaybeGzip, parseJsonBody } from './utils/http.utils.js';
+import { exportTables, importTables, MANGA_SYNC_TABLES, TV_SYNC_TABLES, ASMR_SYNC_TABLES, normalizePayload as normalizeGenericPayload, readPayloadVersion, } from './sync-payload.js';
+const GOOGLE_REQUEST_TIMEOUT_MS = 30000;
+export class GoogleDriveService {
+    tokens = {};
+    folderIdCache = new Map();
+    constructor() {
+        // Client ID/secret now live in Cloudflare Worker (GOOGLE_AUTH_WORKER_URL).
+        // Legacy user-owned .env credentials are optional fallback only.
+        if (!CONFIG.GOOGLE_AUTH_WORKER_URL && !CONFIG.GOOGLE_CLIENT_ID) {
+            logger.error('GOOGLE_AUTH_WORKER_URL is missing and no GOOGLE_CLIENT_ID fallback!');
+        }
+        this.loadTokens();
+    }
+    useWorker() {
+        return !!CONFIG.GOOGLE_AUTH_WORKER_URL;
+    }
+    loadTokens() {
+        if (fs.existsSync(CONFIG.TOKEN_PATH)) {
+            try {
+                this.tokens = JSON.parse(fs.readFileSync(CONFIG.TOKEN_PATH, 'utf-8'));
+            }
+            catch (error) {
+                logger.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.writeFileSync(CONFIG.TOKEN_PATH, JSON.stringify(this.tokens));
+        }
+        catch (error) {
+            logger.error({ err: error }, 'Failed to save refreshed tokens');
+        }
+    }
+    getGoogleClientConfig() {
+        // Legacy fallback only. Preferred path is Worker (no secret in dango).
+        return {
+            clientId: CONFIG.GOOGLE_CLIENT_ID || '',
+            clientSecret: CONFIG.GOOGLE_CLIENT_SECRET || '',
+        };
+    }
+    async postJson(url, payload) {
+        const response = await fetchWithRetry(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+        }, { timeoutMs: GOOGLE_REQUEST_TIMEOUT_MS });
+        if (!response.ok)
+            throw new HttpError(response.status);
+        return parseJsonBody(response);
+    }
+    async postForm(url, params) {
+        const response = await fetchWithRetry(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: params.toString(),
+        }, { timeoutMs: GOOGLE_REQUEST_TIMEOUT_MS });
+        if (!response.ok)
+            throw new HttpError(response.status);
+        return parseJsonBody(response);
+    }
+    async refreshViaWorker() {
+        if (!this.tokens.refresh_token)
+            return false;
+        try {
+            const data = await this.postJson(`${CONFIG.GOOGLE_AUTH_WORKER_URL}/refresh`, {
+                refresh_token: this.tokens.refresh_token,
+            });
+            this.saveTokens(data);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof HttpError && (error.status === 400 || error.status === 401)) {
+                logger.warn('Worker refresh failed. Token may be revoked. Logging out.');
+                await this.logout();
+            }
+            throw error;
+        }
+    }
+    async refreshAccessToken() {
+        if (!this.tokens.refresh_token) {
+            throw new Error('Missing refresh token');
+        }
+        // Preferred: secret stays in Worker
+        if (this.useWorker()) {
+            await this.refreshViaWorker();
+            return;
+        }
+        const { clientId, clientSecret } = this.getGoogleClientConfig();
+        if (!clientId || !clientSecret) {
+            throw new Error('Google OAuth credentials are not configured');
+        }
+        const params = new URLSearchParams({
+            client_id: clientId,
+            client_secret: clientSecret,
+            refresh_token: this.tokens.refresh_token,
+            grant_type: 'refresh_token',
+        });
+        try {
+            const data = await this.postForm('https://oauth2.googleapis.com/token', params);
+            this.saveTokens(data);
+        }
+        catch (error) {
+            if (error instanceof HttpError && (error.status === 400 || error.status === 401)) {
+                logger.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();
+        }
+    }
+    withParams(url, params) {
+        if (!params)
+            return url;
+        const parsed = new URL(url);
+        for (const [key, value] of Object.entries(params)) {
+            if (value === undefined || value === null)
+                continue;
+            parsed.searchParams.set(key, String(value));
+        }
+        return parsed.toString();
+    }
+    serializeBody(data) {
+        if (data === undefined || data === null)
+            return {};
+        if (typeof data === 'string')
+            return { body: data };
+        if (data instanceof Uint8Array || data instanceof Readable) {
+            return { body: data, duplex: 'half' };
+        }
+        return { body: JSON.stringify(data) };
+    }
+    async googleRequest(config) {
+        await this.ensureAccessToken();
+        try {
+            const { body, duplex } = this.serializeBody(config.data);
+            const response = await fetchWithRetry(this.withParams(config.url, config.params), {
+                method: config.method,
+                headers: {
+                    Authorization: `Bearer ${this.tokens.access_token}`,
+                    ...(config.headers ?? {}),
+                },
+                ...(body !== undefined ? { body } : {}),
+                ...(duplex ? { duplex } : {}),
+            }, { timeoutMs: GOOGLE_REQUEST_TIMEOUT_MS });
+            if (!response.ok) {
+                try {
+                    await response.body?.cancel();
+                }
+                catch {
+                    // ignore
+                }
+                throw new HttpError(response.status);
+            }
+            if (config.responseType === 'stream') {
+                if (!response.body)
+                    throw new HttpError(response.status, 'Empty upstream body');
+                return {
+                    data: Readable.from(response.body),
+                    status: response.status,
+                    headers: response.headers,
+                };
+            }
+            if (config.responseType === 'text') {
+                return {
+                    data: (await response.text()),
+                    status: response.status,
+                    headers: response.headers,
+                };
+            }
+            const text = decodeMaybeGzip(Buffer.from(await response.arrayBuffer())).toString('utf8');
+            return {
+                data: (text ? JSON.parse(text) : undefined),
+                status: response.status,
+                headers: response.headers,
+            };
+        }
+        catch (error) {
+            if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
+                logger.warn('Google API request failed with auth error. Logging out.');
+                await this.logout();
+            }
+            throw error;
+        }
+    }
+    isAuthenticated() {
+        return !!this.tokens.refresh_token;
+    }
+    async getAuthUrl() {
+        // Preferred: Worker builds URL with bundled client_id, no secret needed here
+        if (this.useWorker()) {
+            try {
+                const url = new URL(`${CONFIG.GOOGLE_AUTH_WORKER_URL}/auth-url`);
+                url.searchParams.set('redirect_uri', CONFIG.GOOGLE_REDIRECT_URI);
+                const response = await fetchWithRetry(url, {}, { timeoutMs: GOOGLE_REQUEST_TIMEOUT_MS });
+                if (!response.ok)
+                    throw new HttpError(response.status);
+                const data = await parseJsonBody(response);
+                if (data?.url)
+                    return data.url;
+            }
+            catch (error) {
+                logger.error({ err: error }, 'Worker /auth-url failed, falling back to local');
+            }
+        }
+        const { clientId } = this.getGoogleClientConfig();
+        if (!clientId)
+            throw new Error('Google OAuth credentials are not configured');
+        const url = new URL('https://accounts.google.com/o/oauth2/v2/auth');
+        url.searchParams.set('client_id', clientId);
+        url.searchParams.set('redirect_uri', 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.GOOGLE_SCOPES.join(' '));
+        return url.toString();
+    }
+    async handleCallback(code) {
+        // Preferred: Worker exchanges code with secret, dango never sees secret
+        if (this.useWorker()) {
+            try {
+                const data = await this.postJson(`${CONFIG.GOOGLE_AUTH_WORKER_URL}/exchange`, { code, redirect_uri: CONFIG.GOOGLE_REDIRECT_URI });
+                this.saveTokens(data);
+                return this.tokens;
+            }
+            catch (error) {
+                logger.error({ err: error }, 'Worker /exchange failed');
+                throw error;
+            }
+        }
+        // Legacy fallback: user-owned client_id/secret in .env
+        const { clientId, clientSecret } = this.getGoogleClientConfig();
+        const params = new URLSearchParams({
+            code,
+            client_id: clientId,
+            client_secret: clientSecret,
+            redirect_uri: CONFIG.GOOGLE_REDIRECT_URI,
+            grant_type: 'authorization_code',
+        });
+        const data = await this.postForm('https://oauth2.googleapis.com/token', params);
+        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.error({ err: error }, 'Failed to fetch user profile');
+            if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
+                logger.warn('Google authentication token is invalid or expired. Logging out.');
+                await this.logout();
+            }
+            return null;
+        }
+    }
+    async logout() {
+        if (fs.existsSync(CONFIG.TOKEN_PATH)) {
+            fs.unlinkSync(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.error({ err: error }, `Failed to create folder ${folderName}`);
+            throw error;
+        }
+    }
+    async listFiles(folderId) {
+        if (!this.isAuthenticated())
+            return [];
+        try {
+            const res = await this.googleRequest({
+                method: 'GET',
+                url: 'https://www.googleapis.com/drive/v3/files',
+                params: {
+                    q: `'${folderId}' in parents and trashed = false`,
+                    fields: 'files(id, name)',
+                    spaces: 'drive',
+                },
+            });
+            return res.data.files || [];
+        }
+        catch (error) {
+            logger.error({ err: error }, 'Failed to list files in folder');
+            return [];
+        }
+    }
+    async deleteFile(fileId) {
+        if (!this.isAuthenticated())
+            return;
+        try {
+            await this.googleRequest({
+                method: 'DELETE',
+                url: `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}`,
+            });
+        }
+        catch (error) {
+            logger.warn({ err: error }, `Failed to delete file ${fileId}`);
+        }
+    }
+    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.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.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.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 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.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.error({ err: error }, `Failed to upload file ${filename}`);
+            throw error;
+        }
+    }
+    getSyncFilename() {
+        return CONFIG.GOOGLE_SYNC_FILENAME || 'sync.json';
+    }
+    getMangaSyncFilename() {
+        return (CONFIG.MANGA_GOOGLE_SYNC_FILENAME ||
+            'manga.sync.json');
+    }
+    getTvSyncFilename() {
+        return (CONFIG.TV_GOOGLE_SYNC_FILENAME || 'tv.sync.json');
+    }
+    getAsmrSyncFilename() {
+        return (CONFIG.ASMR_GOOGLE_SYNC_FILENAME ||
+            'asmr.sync.json');
+    }
+    async findFileInAppData(filename) {
+        if (!this.isAuthenticated())
+            return null;
+        const safeName = filename.replace(/'/g, "\\'");
+        try {
+            const res = await this.googleRequest({
+                method: 'GET',
+                url: 'https://www.googleapis.com/drive/v3/files',
+                params: {
+                    q: `name = '${safeName}' and trashed = false`,
+                    fields: 'files(id, name)',
+                    spaces: 'appDataFolder',
+                    orderBy: 'createdTime desc',
+                },
+            });
+            if (res.data.files && res.data.files.length > 0) {
+                return { id: res.data.files[0].id, name: res.data.files[0].name };
+            }
+            return null;
+        }
+        catch (error) {
+            logger.error({ err: error }, `Error searching appDataFolder for ${filename}`);
+            throw error;
+        }
+    }
+    async downloadJson(fileId) {
+        const res = await this.googleRequest({
+            method: 'GET',
+            url: `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}`,
+            params: { alt: 'media' },
+            responseType: 'text',
+        });
+        return typeof res.data === 'string' ? JSON.parse(res.data) : res.data;
+    }
+    async uploadJson(filename, payload, existingId) {
+        const content = JSON.stringify(payload, null, 2);
+        if (existingId) {
+            await this.googleRequest({
+                method: 'PATCH',
+                url: `https://www.googleapis.com/upload/drive/v3/files/${encodeURIComponent(existingId)}`,
+                params: { uploadType: 'media' },
+                data: content,
+                headers: { 'Content-Type': 'application/json' },
+            });
+            return;
+        }
+        const created = await this.googleRequest({
+            method: 'POST',
+            url: 'https://www.googleapis.com/drive/v3/files',
+            params: { fields: 'id' },
+            data: { name: filename, parents: ['appDataFolder'] },
+            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: content,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    async getRemoteVersion() {
+        if (!this.isAuthenticated())
+            return 0;
+        const file = await this.findFileInAppData(this.getSyncFilename());
+        if (!file)
+            return 0;
+        try {
+            const payload = (await this.downloadJson(file.id));
+            const row = payload?.tables?.sync_metadata?.find((r) => r.key === 'db_version');
+            const v = row?.value;
+            return typeof v === 'number' ? v : Number(v || payload?.version || 0);
+        }
+        catch {
+            return 0;
+        }
+    }
+    async getMangaRemoteVersion() {
+        if (!this.isAuthenticated())
+            return 0;
+        const file = await this.findFileInAppData(this.getMangaSyncFilename());
+        if (!file)
+            return 0;
+        try {
+            const payload = (await this.downloadJson(file.id));
+            const row = payload?.tables?.sync_metadata?.find((r) => r.key === 'db_version');
+            const v = row?.value;
+            return typeof v === 'number' ? v : Number(v || payload?.version || 0);
+        }
+        catch {
+            return 0;
+        }
+    }
+    async syncUp(db) {
+        if (!this.isAuthenticated())
+            return;
+        const payload = await this.exportDatabase(db);
+        const existing = await this.findFileInAppData(this.getSyncFilename());
+        await this.uploadJson(this.getSyncFilename(), payload, existing?.id);
+    }
+    async syncDown(db) {
+        if (!this.isAuthenticated())
+            return 0;
+        const file = await this.findFileInAppData(this.getSyncFilename());
+        if (!file)
+            return 0;
+        const payload = (await this.downloadJson(file.id));
+        this.importDatabase(db, payload);
+        const row = payload.tables?.sync_metadata?.find((r) => r.key === 'db_version');
+        return Number(row?.value || payload.version || 0);
+    }
+    async syncMangaUp(db) {
+        if (!this.isAuthenticated())
+            return;
+        const payload = exportTables(db, MANGA_SYNC_TABLES);
+        const existing = await this.findFileInAppData(this.getMangaSyncFilename());
+        await this.uploadJson(this.getMangaSyncFilename(), payload, existing?.id);
+    }
+    async syncMangaDown(db) {
+        if (!this.isAuthenticated())
+            return 0;
+        const file = await this.findFileInAppData(this.getMangaSyncFilename());
+        if (!file)
+            return 0;
+        const raw = await this.downloadJson(file.id);
+        const payload = normalizeGenericPayload(raw, MANGA_SYNC_TABLES, 'Google manga');
+        importTables(db, MANGA_SYNC_TABLES, payload, {
+            libraryTables: ['manga_library', 'manga_progress'],
+            backupName: 'pre-sync-manga-backup.db',
+        });
+        return readPayloadVersion(payload);
+    }
+    async getTvRemoteVersion() {
+        if (!this.isAuthenticated())
+            return 0;
+        const file = await this.findFileInAppData(this.getTvSyncFilename());
+        if (!file)
+            return 0;
+        try {
+            const payload = (await this.downloadJson(file.id));
+            const row = payload?.tables?.sync_metadata?.find((r) => r.key === 'db_version');
+            const v = row?.value;
+            return typeof v === 'number' ? v : Number(v || payload?.version || 0);
+        }
+        catch {
+            return 0;
+        }
+    }
+    async syncTvUp(db) {
+        if (!this.isAuthenticated())
+            return;
+        const payload = exportTables(db, TV_SYNC_TABLES);
+        const existing = await this.findFileInAppData(this.getTvSyncFilename());
+        await this.uploadJson(this.getTvSyncFilename(), payload, existing?.id);
+    }
+    async syncTvDown(db) {
+        if (!this.isAuthenticated())
+            return 0;
+        const file = await this.findFileInAppData(this.getTvSyncFilename());
+        if (!file)
+            return 0;
+        const raw = await this.downloadJson(file.id);
+        const payload = normalizeGenericPayload(raw, TV_SYNC_TABLES, 'Google TV');
+        importTables(db, TV_SYNC_TABLES, payload, {
+            libraryTables: ['tv_library', 'tv_progress'],
+            backupName: 'pre-sync-tv-backup.db',
+        });
+        return readPayloadVersion(payload);
+    }
+    async getAsmrRemoteVersion() {
+        if (!this.isAuthenticated())
+            return 0;
+        const file = await this.findFileInAppData(this.getAsmrSyncFilename());
+        if (!file)
+            return 0;
+        try {
+            const payload = (await this.downloadJson(file.id));
+            const row = payload?.tables?.sync_metadata?.find((r) => r.key === 'db_version');
+            const v = row?.value;
+            return typeof v === 'number' ? v : Number(v || payload?.version || 0);
+        }
+        catch {
+            return 0;
+        }
+    }
+    async syncAsmrUp(db) {
+        if (!this.isAuthenticated())
+            return;
+        const payload = exportTables(db, ASMR_SYNC_TABLES);
+        const existing = await this.findFileInAppData(this.getAsmrSyncFilename());
+        await this.uploadJson(this.getAsmrSyncFilename(), payload, existing?.id);
+    }
+    async syncAsmrDown(db) {
+        if (!this.isAuthenticated())
+            return 0;
+        const file = await this.findFileInAppData(this.getAsmrSyncFilename());
+        if (!file)
+            return 0;
+        const raw = await this.downloadJson(file.id);
+        const payload = normalizeGenericPayload(raw, ASMR_SYNC_TABLES, 'Google ASMR');
+        importTables(db, ASMR_SYNC_TABLES, payload, {
+            libraryTables: ['asmr_library', 'asmr_progress'],
+            backupName: 'pre-sync-asmr-backup.db',
+        });
+        return readPayloadVersion(payload);
+    }
+    async exportDatabase(db) {
+        const tables = [
+            'watchlist',
+            'watched_episodes',
+            'queue',
+            'settings',
+            'shows_meta',
+            'sync_metadata',
+            'dismissed_notifications',
+            'discovered_notifications',
+        ];
+        const out = {};
+        for (const table of tables) {
+            out[table] = dbAll(db, `SELECT * FROM "${table.replace(/"/g, '""')}"`).filter((row) => !isTempSyncRow(row));
+        }
+        const versionRow = out.sync_metadata.find((r) => r.key === 'db_version');
+        return {
+            version: Number(versionRow?.value || 0),
+            exportedAt: new Date().toISOString(),
+            tables: out,
+        };
+    }
+    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) {
+            logger.warn({ err }, 'Pre-sync backup failed, continuing without backup');
+        }
+        const tables = [
+            'watchlist',
+            'watched_episodes',
+            'queue',
+            'settings',
+            'shows_meta',
+            'sync_metadata',
+            'dismissed_notifications',
+            'discovered_notifications',
+        ];
+        const localColumns = new Map();
+        for (const table of 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 tables) {
+                db.run(`DELETE FROM "${table}"`);
+            }
+            for (const table of 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((c) => `"${c.replace(/"/g, '""')}"`).join(', ');
+                    const placeholders = columns.map(() => '?').join(', ');
+                    const values = columns.map((c) => row[c]);
+                    db.run(`INSERT INTO "${table}" (${columnSql}) VALUES (${placeholders})`, values);
+                }
+            }
+        });
+    }
+}
+export const googleDriveService = new GoogleDriveService();