@serifpersia/dango 3.0.3

package/server/dist/app-auth.js

@@ -0,0 +1,231 @@
+"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.LAN_AUTH_COOKIE = void 0;
+exports.getAppPasswordHash = getAppPasswordHash;
+exports.hasAppPassword = hasAppPassword;
+exports.hashAppPassword = hashAppPassword;
+exports.verifyAppPassword = verifyAppPassword;
+exports.setAppPassword = setAppPassword;
+exports.createLanSession = createLanSession;
+exports.validateLanSession = validateLanSession;
+exports.revokeLanSession = revokeLanSession;
+exports.clearAllLanSessions = clearAllLanSessions;
+exports.isLoopbackRequest = isLoopbackRequest;
+exports.getRequestToken = getRequestToken;
+exports.isLanAuthenticated = isLanAuthenticated;
+exports.lanAuthMiddleware = lanAuthMiddleware;
+exports.buildLanCookie = buildLanCookie;
+exports.clearLanCookie = clearLanCookie;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("./config");
+exports.LAN_AUTH_COOKIE = 'dango_lan_auth';
+const SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+function sessionsFile() {
+    return path_1.default.join(config_1.CONFIG.ROOT, 'lan_sessions.json');
+}
+function loadSessions() {
+    try {
+        if (!fs_1.default.existsSync(sessionsFile()))
+            return {};
+        const raw = fs_1.default.readFileSync(sessionsFile(), 'utf8');
+        const parsed = JSON.parse(raw);
+        const now = Date.now();
+        let dirty = false;
+        for (const [token, expiry] of Object.entries(parsed)) {
+            if (typeof expiry !== 'number' || expiry < now) {
+                delete parsed[token];
+                dirty = true;
+            }
+        }
+        if (dirty)
+            saveSessions(parsed);
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+function saveSessions(sessions) {
+    try {
+        fs_1.default.mkdirSync(config_1.CONFIG.ROOT, { recursive: true });
+        fs_1.default.writeFileSync(sessionsFile(), JSON.stringify(sessions));
+    }
+    catch {
+        // sessions won't be saved if disk write fails
+    }
+}
+function getAppPasswordHash() {
+    return process.env.APP_PASSWORD_HASH || config_1.CONFIG.APP_PASSWORD_HASH || '';
+}
+function hasAppPassword() {
+    return !!getAppPasswordHash();
+}
+function hashAppPassword(password) {
+    const salt = crypto_1.default.randomBytes(16).toString('hex');
+    const hash = crypto_1.default.scryptSync(password, salt, 32).toString('hex');
+    return `scrypt:${salt}:${hash}`;
+}
+function verifyAppPassword(password) {
+    const stored = getAppPasswordHash();
+    if (!stored)
+        return false;
+    const parts = stored.split(':');
+    if (parts.length !== 3 || parts[0] !== 'scrypt')
+        return false;
+    const [, salt, expectedHex] = parts;
+    try {
+        const derived = crypto_1.default.scryptSync(password, salt, 32);
+        const expected = Buffer.from(expectedHex, 'hex');
+        if (derived.length !== expected.length)
+            return false;
+        return crypto_1.default.timingSafeEqual(derived, expected);
+    }
+    catch {
+        return false;
+    }
+}
+async function setAppPassword(password) {
+    const { updateEnvFile } = await Promise.resolve().then(() => __importStar(require('./utils/env.utils')));
+    if (!password) {
+        await updateEnvFile({ APP_PASSWORD_HASH: '' });
+        config_1.CONFIG.APP_PASSWORD_HASH = '';
+        return;
+    }
+    const hash = hashAppPassword(password);
+    await updateEnvFile({ APP_PASSWORD_HASH: hash });
+    config_1.CONFIG.APP_PASSWORD_HASH = hash;
+}
+function createLanSession() {
+    const token = crypto_1.default.randomBytes(32).toString('hex');
+    const expiry = Date.now() + SESSION_TTL_MS;
+    const sessions = loadSessions();
+    sessions[token] = expiry;
+    saveSessions(sessions);
+    return { token, expiry };
+}
+function validateLanSession(token) {
+    if (!token)
+        return false;
+    const sessions = loadSessions();
+    const expiry = sessions[token];
+    if (!expiry)
+        return false;
+    if (expiry < Date.now()) {
+        delete sessions[token];
+        saveSessions(sessions);
+        return false;
+    }
+    return true;
+}
+function revokeLanSession(token) {
+    if (!token)
+        return;
+    const sessions = loadSessions();
+    if (sessions[token]) {
+        delete sessions[token];
+        saveSessions(sessions);
+    }
+}
+function clearAllLanSessions() {
+    saveSessions({});
+}
+function normalizeIp(ip) {
+    if (!ip)
+        return '';
+    if (ip.startsWith('::ffff:'))
+        return ip.slice('::ffff:'.length);
+    return ip;
+}
+function isLoopbackRequest(req) {
+    const candidates = [req.ip, req.socket?.remoteAddress].map((v) => normalizeIp(v));
+    return candidates.includes('127.0.0.1') || candidates.includes('::1');
+}
+function getRequestToken(req) {
+    const auth = req.headers.authorization;
+    if (auth && auth.toLowerCase().startsWith('bearer ')) {
+        return auth.slice(7).trim() || null;
+    }
+    const cookieHeader = req.headers.cookie;
+    if (cookieHeader) {
+        const parts = cookieHeader.split(';');
+        for (const part of parts) {
+            const idx = part.indexOf('=');
+            if (idx === -1)
+                continue;
+            const name = part.slice(0, idx).trim();
+            if (name === exports.LAN_AUTH_COOKIE) {
+                return decodeURIComponent(part.slice(idx + 1).trim()) || null;
+            }
+        }
+    }
+    return null;
+}
+function isLanAuthenticated(req) {
+    if (!hasAppPassword())
+        return true;
+    return validateLanSession(getRequestToken(req));
+}
+const PUBLIC_PATHS = new Set([
+    '/api/auth/app-status',
+    '/api/auth/app-login',
+    '/api/auth/app-logout',
+    '/api/internal/shutdown',
+]);
+function lanAuthMiddleware(req, res, next) {
+    if (!req.path.startsWith('/api/'))
+        return next();
+    if (PUBLIC_PATHS.has(req.path))
+        return next();
+    if (req.path.startsWith('/api/internal/') && isLoopbackRequest(req))
+        return next();
+    if (!hasAppPassword())
+        return next();
+    if (validateLanSession(getRequestToken(req)))
+        return next();
+    return res.status(401).json({ error: 'LAN_AUTH_REQUIRED' });
+}
+function buildLanCookie(token, expiry) {
+    const maxAge = Math.max(1, Math.floor((expiry - Date.now()) / 1000));
+    return `${exports.LAN_AUTH_COOKIE}=${encodeURIComponent(token)}; HttpOnly; Path=/; Max-Age=${maxAge}; SameSite=Lax`;
+}
+function clearLanCookie() {
+    return `${exports.LAN_AUTH_COOKIE}=; HttpOnly; Path=/; Max-Age=0; SameSite=Lax`;
+}

package/server/dist/config.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG = exports.SERVER_ROOT = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const shipped_defaults_1 = require("./shipped-defaults");
+exports.SERVER_ROOT = path_1.default.resolve(__dirname, '..');
+const PACKAGE_ROOT = path_1.default.resolve(exports.SERVER_ROOT, '..');
+function resolveDataRoot() {
+    if (process.platform === 'win32' && process.env.APPDATA) {
+        return path_1.default.join(process.env.APPDATA, 'dango');
+    }
+    if (process.platform === 'darwin') {
+        return path_1.default.join(os_1.default.homedir(), 'Library', 'Application Support', 'dango');
+    }
+    if (process.env.XDG_DATA_HOME) {
+        return path_1.default.join(process.env.XDG_DATA_HOME, 'dango');
+    }
+    return path_1.default.join(os_1.default.homedir(), '.local', 'share', 'dango');
+}
+function moveFileIfNeeded(sourcePath, destinationPath) {
+    if (!fs_1.default.existsSync(sourcePath) || fs_1.default.existsSync(destinationPath)) {
+        return;
+    }
+    try {
+        fs_1.default.renameSync(sourcePath, destinationPath);
+    }
+    catch {
+        fs_1.default.copyFileSync(sourcePath, destinationPath);
+        fs_1.default.unlinkSync(sourcePath);
+    }
+}
+function migrateLegacyData(packageServerRoot, dataRoot) {
+    const legacyFiles = [
+        '.env',
+        'google_tokens.json',
+        'sync_manifest.json',
+        'sync_manifest.dev.json',
+        'anime.db',
+        'anime.db-shm',
+        'anime.db-wal',
+        'anime.dev.db',
+        'anime.dev.db-shm',
+        'anime.dev.db-wal',
+    ];
+    fs_1.default.mkdirSync(dataRoot, { recursive: true });
+    for (const filename of legacyFiles) {
+        moveFileIfNeeded(path_1.default.join(packageServerRoot, filename), path_1.default.join(dataRoot, filename));
+    }
+}
+function resolveLegacyDataRoot() {
+    if (process.platform === 'win32' && process.env.APPDATA) {
+        return path_1.default.join(process.env.APPDATA, 'ani-web');
+    }
+    if (process.platform === 'darwin') {
+        return path_1.default.join(os_1.default.homedir(), 'Library', 'Application Support', 'ani-web');
+    }
+    if (process.env.XDG_DATA_HOME) {
+        return path_1.default.join(process.env.XDG_DATA_HOME, 'ani-web');
+    }
+    return path_1.default.join(os_1.default.homedir(), '.local', 'share', 'ani-web');
+}
+function migrateFromAniWeb(dataRoot) {
+    const legacyRoot = resolveLegacyDataRoot();
+    if (legacyRoot === dataRoot)
+        return;
+    if (!fs_1.default.existsSync(legacyRoot))
+        return;
+    const filesToMigrate = [
+        '.env',
+        'google_tokens.json',
+        'sync_manifest.json',
+        'sync_manifest.dev.json',
+        'anime.db',
+        'anime.db-shm',
+        'anime.db-wal',
+        'anime.dev.db',
+        'anime.dev.db-shm',
+        'anime.dev.db-wal',
+    ];
+    fs_1.default.mkdirSync(dataRoot, { recursive: true });
+    for (const filename of filesToMigrate) {
+        moveFileIfNeeded(path_1.default.join(legacyRoot, filename), path_1.default.join(dataRoot, filename));
+    }
+}
+const DATA_ROOT = resolveDataRoot();
+const ENV_PATH = path_1.default.join(DATA_ROOT, '.env');
+migrateLegacyData(exports.SERVER_ROOT, DATA_ROOT);
+migrateFromAniWeb(DATA_ROOT);
+dotenv_1.default.config({ path: path_1.default.join(exports.SERVER_ROOT, '.env') });
+dotenv_1.default.config({ path: ENV_PATH, override: true });
+const IS_DEV = process.argv.includes('--dev');
+const PORT = 3000;
+const HOST = process.env.HOST || '0.0.0.0';
+const GOOGLE_REDIRECT_URI = IS_DEV
+    ? 'http://localhost:5173/api/auth/google/callback'
+    : `http://localhost:${PORT}/api/auth/google/callback`;
+exports.CONFIG = {
+    ROOT: DATA_ROOT,
+    SERVER_ROOT: exports.SERVER_ROOT,
+    PACKAGE_ROOT,
+    ENV_PATH,
+    TOKEN_PATH: path_1.default.join(DATA_ROOT, 'google_tokens.json'),
+    LOCAL_MANIFEST_PATH: path_1.default.join(DATA_ROOT, IS_DEV ? 'sync_manifest.dev.json' : 'sync_manifest.json'),
+    DB_NAME_PROD: 'anime.db',
+    DB_NAME_DEV: 'anime.dev.db',
+    REMOTE_FOLDER_PROD: 'dango_db',
+    REMOTE_FOLDER_DEV: 'dango_dev_db',
+    MANIFEST_FILENAME: IS_DEV ? 'sync_manifest.dev.json' : 'sync_manifest.json',
+    GOOGLE_SCOPES: [
+        'https://www.googleapis.com/auth/drive.appdata',
+        'https://www.googleapis.com/auth/drive.file',
+        'https://www.googleapis.com/auth/userinfo.email',
+    ],
+    GOOGLE_SYNC_FILENAME: IS_DEV ? 'sync.dev.json' : 'sync.json',
+    RCLONE_SYNC_FILENAME: IS_DEV ? 'sync.dev.json' : 'sync.json',
+    IS_DEV,
+    PORT,
+    HOST,
+    GOOGLE_CLIENT_ID: process.env.GOOGLE_CLIENT_ID,
+    GOOGLE_CLIENT_SECRET: process.env.GOOGLE_CLIENT_SECRET,
+    GOOGLE_REDIRECT_URI: GOOGLE_REDIRECT_URI,
+    GOOGLE_AUTH_WORKER_URL: process.env.GOOGLE_AUTH_WORKER_URL || shipped_defaults_1.SHIPPED_DEFAULTS.GOOGLE_AUTH_WORKER_URL || '',
+    RCLONE_REMOTE: process.env.RCLONE_REMOTE,
+    SYNC_PROVIDER: process.env.SYNC_PROVIDER,
+    DISCORD_CLIENT_ID: process.env.DISCORD_CLIENT_ID || shipped_defaults_1.SHIPPED_DEFAULTS.DISCORD_CLIENT_ID || undefined,
+    APP_PASSWORD_HASH: process.env.APP_PASSWORD_HASH || '',
+};

package/server/dist/controllers/auth.controller.js

@@ -0,0 +1,247 @@
+"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.AuthController = void 0;
+const logger_1 = __importDefault(require("../logger"));
+const google_1 = require("../google");
+const github_sync_1 = require("../github-sync");
+const sync_1 = require("../sync");
+const config_1 = require("../config");
+const rclone_1 = require("../rclone");
+class AuthController {
+    runSyncSequence;
+    constructor(runSyncSequence) {
+        this.runSyncSequence = runSyncSequence;
+    }
+    getConfigStatus = (_req, res) => {
+        // New flow: Worker holds ID+secret, no local .env needed.
+        // Legacy fallback: user-owned GOOGLE_CLIENT_ID + GOOGLE_CLIENT_SECRET.
+        const useWorker = !!config_1.CONFIG.GOOGLE_AUTH_WORKER_URL;
+        const hasLegacyConfig = !!process.env.GOOGLE_CLIENT_ID && !!process.env.GOOGLE_CLIENT_SECRET;
+        res.json({ hasConfig: useWorker || hasLegacyConfig, useWorker });
+    };
+    getGoogleAuthSettings = (_req, res) => {
+        res.json({
+            useWorker: !!config_1.CONFIG.GOOGLE_AUTH_WORKER_URL,
+            hasCustomWorkerUrl: !!process.env.GOOGLE_AUTH_WORKER_URL,
+            hasCustomClientId: !!process.env.GOOGLE_CLIENT_ID,
+            hasClientSecret: !!process.env.GOOGLE_CLIENT_SECRET,
+        });
+    };
+    updateGoogleAuthSettings = async (req, res) => {
+        const { clientId, clientSecret, workerUrl } = req.body;
+        const { updateEnvFile } = await Promise.resolve().then(() => __importStar(require('../utils/env.utils')));
+        const updates = {};
+        if (typeof clientId === 'string') {
+            updates.GOOGLE_CLIENT_ID = clientId;
+        }
+        if (typeof clientSecret === 'string') {
+            updates.GOOGLE_CLIENT_SECRET = clientSecret;
+        }
+        if (typeof workerUrl === 'string') {
+            updates.GOOGLE_AUTH_WORKER_URL = workerUrl;
+        }
+        await updateEnvFile(updates);
+        if (typeof workerUrl === 'string') {
+            ;
+            config_1.CONFIG.GOOGLE_AUTH_WORKER_URL = workerUrl;
+        }
+        if (typeof clientId === 'string') {
+            ;
+            config_1.CONFIG.GOOGLE_CLIENT_ID = clientId || undefined;
+        }
+        if (typeof clientSecret === 'string') {
+            ;
+            config_1.CONFIG.GOOGLE_CLIENT_SECRET =
+                clientSecret || undefined;
+        }
+        await (0, sync_1.initSyncProvider)();
+        res.json({ success: true });
+    };
+    getGitHubAuthOverride = (_req, res) => {
+        res.json({ hasCustomClientId: !!process.env.GITHUB_CLIENT_ID });
+    };
+    updateGitHubAuthSettings = async (req, res) => {
+        const { clientId } = req.body;
+        const { updateEnvFile } = await Promise.resolve().then(() => __importStar(require('../utils/env.utils')));
+        if (typeof clientId !== 'string') {
+            return res.status(400).json({ error: 'clientId required' });
+        }
+        await updateEnvFile({ GITHUB_CLIENT_ID: clientId });
+        res.json({ success: true });
+    };
+    getRcloneSettings = async (_req, res) => {
+        const remotes = await rclone_1.rcloneService.listRemotes();
+        res.json({
+            remote: config_1.CONFIG.RCLONE_REMOTE || '',
+            availableRemotes: remotes,
+            activeRemote: rclone_1.rcloneService.isActive() ? rclone_1.rcloneService.getRemoteName() : null,
+        });
+    };
+    getSyncSettings = async (_req, res) => {
+        const { getActiveProvider } = await Promise.resolve().then(() => __importStar(require('../sync')));
+        res.json({
+            activeProvider: process.env.SYNC_PROVIDER || 'default',
+            actualActiveProvider: getActiveProvider(),
+            authenticatedProviders: {
+                github: github_sync_1.githubSyncService.isAuthenticated(),
+                google: google_1.googleDriveService.isAuthenticated(),
+                rclone: rclone_1.rcloneService.isActive(),
+            },
+        });
+    };
+    updateSyncProvider = async (req, res) => {
+        const { provider } = req.body;
+        const { updateEnvFile } = await Promise.resolve().then(() => __importStar(require('../utils/env.utils')));
+        const value = provider === 'default' ? '' : provider;
+        await updateEnvFile({ SYNC_PROVIDER: value });
+        await (0, sync_1.initSyncProvider)();
+        res.json({ success: true, activeProvider: process.env.SYNC_PROVIDER || 'default' });
+    };
+    getGitHubAuthStatus = async (_req, res) => {
+        try {
+            const user = await github_sync_1.githubSyncService.getUserProfile();
+            res.json({
+                authenticated: !!user,
+                user,
+                device: github_sync_1.githubSyncService.getDeviceState(),
+                hasCustomClientId: !!process.env.GITHUB_CLIENT_ID,
+            });
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, 'Failed to fetch GitHub auth status');
+            res.json({
+                authenticated: false,
+                user: null,
+                device: github_sync_1.githubSyncService.getDeviceState(),
+                hasCustomClientId: !!process.env.GITHUB_CLIENT_ID,
+            });
+        }
+    };
+    startGitHubDeviceAuth = async (req, res) => {
+        const state = await github_sync_1.githubSyncService.startDeviceAuth(req.db, this.runSyncSequence);
+        res.json(state);
+    };
+    pollGitHubDeviceAuth = (_req, res) => {
+        res.json(github_sync_1.githubSyncService.getDeviceState());
+    };
+    logoutGitHub = async (_req, res) => {
+        await github_sync_1.githubSyncService.logout();
+        const { updateEnvFile } = await Promise.resolve().then(() => __importStar(require('../utils/env.utils')));
+        await updateEnvFile({ SYNC_PROVIDER: '' });
+        await (0, sync_1.initSyncProvider)();
+        res.json({ success: true });
+    };
+    updateRcloneSettings = async (req, res) => {
+        const { remote } = req.body;
+        const { updateEnvFile } = await Promise.resolve().then(() => __importStar(require('../utils/env.utils')));
+        await updateEnvFile({
+            RCLONE_REMOTE: remote,
+            SYNC_PROVIDER: 'rclone',
+        });
+        await this.runSyncSequence(req.db, 'rclone');
+        res.json({ success: true });
+    };
+    getAuthUrl = async (_req, res) => {
+        const url = await google_1.googleDriveService.getAuthUrl();
+        res.json({ url });
+    };
+    loginGoogle = async (req, res) => {
+        if (google_1.googleDriveService.isAuthenticated()) {
+            const user = await google_1.googleDriveService.getUserProfile();
+            if (user) {
+                const { updateEnvFile } = await Promise.resolve().then(() => __importStar(require('../utils/env.utils')));
+                await updateEnvFile({ SYNC_PROVIDER: 'google' });
+                await this.runSyncSequence(req.db, 'google');
+                return res.json({ url: null, authenticated: true });
+            }
+            else {
+                logger_1.default.warn('Google tokens found but invalid. Clearing and requesting new auth.');
+                await google_1.googleDriveService.logout();
+            }
+        }
+        const url = await google_1.googleDriveService.getAuthUrl();
+        res.json({ url, authenticated: false });
+    };
+    handleCallback = async (req, res) => {
+        const code = req.query.code;
+        if (!code) {
+            return res.status(400).send('No code provided');
+        }
+        await google_1.googleDriveService.handleCallback(code);
+        const user = await google_1.googleDriveService.getUserProfile();
+        const { updateEnvFile } = await Promise.resolve().then(() => __importStar(require('../utils/env.utils')));
+        await updateEnvFile({ SYNC_PROVIDER: 'google' });
+        logger_1.default.info('User logged in. Syncing database (please wait)...');
+        try {
+            await this.runSyncSequence(req.db, 'google');
+        }
+        catch (err) {
+            logger_1.default.error({ err }, 'Post-login sync failed');
+        }
+        const responseHtml = `
+            <html>
+            <body>
+            <h1>Authentication Successful</h1>
+            <p>Database synced. Closing window...</p>
+            <script>
+            if (window.opener) {
+                window.opener.postMessage({ type: 'GOOGLE_AUTH_SUCCESS', user: ${JSON.stringify(user)} }, window.location.origin);
+                window.close();
+            } else {
+                window.location.href = '/';
+            }
+            </script>
+            </body>
+            </html>
+            `;
+        res.send(responseHtml);
+    };
+    getUserProfile = async (_req, res) => {
+        const user = await google_1.googleDriveService.getUserProfile();
+        res.json(user);
+    };
+    logout = async (_req, res) => {
+        await google_1.googleDriveService.logout();
+        const { updateEnvFile } = await Promise.resolve().then(() => __importStar(require('../utils/env.utils')));
+        await updateEnvFile({ SYNC_PROVIDER: '' });
+        await (0, sync_1.initSyncProvider)();
+        res.json({ success: true });
+    };
+}
+exports.AuthController = AuthController;