Skip to content

A modern, self-hosted backup solution for secure, encrypted backups across local and cloud storage.

10.5 KB
Raw Blame
import path from 'path';
import { fileURLToPath } from 'url';
import express, { type Express } from 'express';
import { IncomingMessage, ServerResponse } from 'http';
import cors from 'cors';
import session from 'express-session';
import createMemoryStore from 'memorystore';
import helmet from 'helmet';
import rateLimit from 'express-rate-limit';
import { db, sqlite } from './db';
import { createPlanRouter } from './routes/plans';
import { createDeviceRouter } from './routes/devices';
import { createStorageRouter } from './routes/storages';
import { createRestoreRouter } from './routes/restores';
import { createUserRouter } from './routes/users';
import { createSettingsRouter } from './routes/settings';
import { createHealthRouter } from './routes/health';
import { createSetupRouter } from './routes/setup';
import { PlanController } from './controllers/PlanController';
import { DeviceController } from './controllers/DeviceController';
import { StorageController } from './controllers/StorageController';
import { RestoreController } from './controllers/RestoreController';
import { UserController } from './controllers/UserController';
import { SettingsController } from './controllers/SettingsController';
import { SetupController } from './controllers/SetupController';
import { createBackupRouter } from './routes/backups';
import { BackupController } from './controllers/BackupController';

import versionMiddleware from './middlewares/versionMiddleware';
import { PlanStore } from './stores/PlanStore';
import { BackupStore } from './stores/BackupStore';
import { PlanService } from './services/PlanService';
import { RestoreStore } from './stores/RestoreStore';
import { SettingsStore } from './stores/SettingsStore';
import { StorageStore } from './stores/StorageStore';
import { DeviceStore } from './stores/DeviceStore';
import { BaseBackupManager } from './managers';
import { BackupEventListener } from './services/listeners/BackupEventListener';
import { ReplicationEventListener } from './services/listeners/ReplicationEventListener';
import { BackupService } from './services/BackupServices';
import { BaseSnapshotManager } from './managers/BaseSnapshotManager';
import { RestoreService } from './services/RestoreService';
import { RestoreEventListener } from './services/listeners/RestoreEventListener';
import { DownloadEventListener } from './services/listeners/DownloadEventListener';
import { DeviceService } from './services/DeviceService';
import { BaseSystemManager } from './managers/BaseSystemManager';
import { BaseStorageManager } from './managers/BaseStorageManager';
import { StorageService } from './services/StorageService';
import { SettingsService } from './services/SettingsService';
import { SelfBackupService } from './services/SelfBackupService';
import { StartupRecovery } from './services/StartupRecovery';
import { SystemTaskManager } from './jobs/SystemTaskManager';
import { SYSTEM_JOBS } from './jobs/systemJobs';
import { jobProcessor } from './jobs/JobProcessor';
import { SelfBackupTask } from './jobs/tasks/SelfBackupTask';
import { initializeLogger } from './utils/logger';
import { configService } from './services/ConfigService';
import { BaseRestoreManager } from './managers/BaseRestoreManager';
import { parseTrustProxy } from './utils/helpers';

const MemoryStore = createMemoryStore(session);

export async function createApp(): Promise<{ app: Express }> {
	// Initialize Logger
	initializeLogger();

	// Stores
	const planStore = new PlanStore(db);
	const backupStore = new BackupStore(db);
	const storageStore = new StorageStore(db);
	const deviceStore = new DeviceStore(db);
	const restoreStore = new RestoreStore(db);
	const settingsStore = new SettingsStore(db);

	// Local Agents
	const localPlanAgent = new BaseBackupManager();
	const localBackupAgent = new BaseSnapshotManager();
	const localRestoreAgent = new BaseRestoreManager();
	const localSystemAgent = new BaseSystemManager();
	const localStorageAgent = new BaseStorageManager();

	// Event Listeners
	new BackupEventListener(localPlanAgent, planStore, backupStore);
	new ReplicationEventListener(localPlanAgent, planStore, backupStore, storageStore);
	new RestoreEventListener(localRestoreAgent, planStore, backupStore, restoreStore);
	new DownloadEventListener(localBackupAgent, backupStore);

	// Main Application Services
	const planService = new PlanService(
		localPlanAgent,
		planStore,
		backupStore,
		storageStore,
		deviceStore,
		restoreStore
	);
	const backupService = new BackupService(
		localBackupAgent,
		localPlanAgent,
		planStore,
		backupStore,
		restoreStore,
		storageStore
	);
	const restoreService = new RestoreService(
		localRestoreAgent,
		planStore,
		backupStore,
		restoreStore,
		storageStore
	);
	const deviceService = new DeviceService(localSystemAgent, deviceStore, planStore, storageStore);
	const storageService = new StorageService(
		localStorageAgent,
		localSystemAgent,
		storageStore,
		planStore,
		settingsStore
	);
	const selfBackupService = new SelfBackupService(settingsStore, storageStore, sqlite, 'core');
	const settingsService = new SettingsService(settingsStore, selfBackupService);

	// API Route Controllers
	const planController = new PlanController(planService);
	const backupController = new BackupController(backupService);
	const restoreController = new RestoreController(restoreService);
	const deviceController = new DeviceController(deviceService);
	const storageController = new StorageController(storageService);
	const settingsController = new SettingsController(settingsService);
	const userController = new UserController(settingsService);
	const setupController = new SetupController();

	// Express App
	const app = express();

	// Reverse proxy support
	const trustProxy = configService.config.TRUST_PROXY;
	if (trustProxy !== undefined && trustProxy !== '') {
		app.set('trust proxy', parseTrustProxy(trustProxy));
	}

	app.use(
		cors({
			origin: [
				process.env.APP_URL as string, // Vite core frontend dev server
				configService.config.APP_URL, // Production domain
			],
			credentials: true,
			methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
			exposedHeaders: ['X-App-Version', 'X-Server-OS', 'X-Install-Type', 'X-Setup-Pending'],
		})
	);

	// Session Middleware for 2FA Setup Process
	app.use(
		session({
			store: new MemoryStore({
				checkPeriod: 86400000,
			}),
			secret: configService.config.SECRET,
			resave: false,
			saveUninitialized: false,
			cookie: {
				secure: configService.config.APP_URL?.startsWith('https'),
				httpOnly: true,
				maxAge: 1000 * 60 * 15,
			},
		})
	);
	app.use(versionMiddleware);
	app.use(express.json());

	// helmet security middleware
	const appUrl = configService.config.APP_URL || 'http://localhost';
	const serverPort = configService.config.SERVER_PORT;
	const isDev = configService.isDevelopment();

	// Dynamically derive the request origin from the Host header.
	// This handles all access methods: localhost, LAN IPs, custom domains,
	// and reverse proxies (Nginx, Traefik, etc.) that set x-forwarded-proto.
	const dynamicOrigin = (req: IncomingMessage, _res: ServerResponse) => {
		const host = req.headers.host;
		if (host) {
			const proto = req.headers['x-forwarded-proto'] === 'https' ? 'https' : 'http';
			return `${proto}://${host}`;
		}
		return `http://localhost:${serverPort}`;
	};

	// In dev, also allow explicit localhost/127.0.0.1 with the backend port
	// so the Vite dev server (different origin) can reach the API.
	const connectSrc: (string | typeof dynamicOrigin)[] = ["'self'", appUrl, dynamicOrigin];
	if (isDev) {
		connectSrc.push(`http://localhost:${serverPort}`, `http://127.0.0.1:${serverPort}`);
	}

	app.use(
		helmet({
			contentSecurityPolicy: {
				directives: {
					defaultSrc: ["'self'"],
					scriptSrc: ["'self'", "'unsafe-inline'"],
					styleSrc: ["'self'", "'unsafe-inline'"],
					imgSrc: ["'self'", 'data:', 'blob:', 'https://pluton.b-cdn.net'],
					fontSrc: ["'self'", 'data:'],
					connectSrc,
					frameAncestors: ["'none'"],
					baseUri: ["'self'"],
					formAction: ["'self'"],
					upgradeInsecureRequests: null,
				},
			},
			hsts: false, // Don't force HTTPS — users may run over HTTP on LAN
		})
	);

	//  Serve static files from the 'public' directory
	// The frontend build files will be placed here
	const __filename = fileURLToPath(import.meta.url);
	const __dirname = path.dirname(__filename);
	const publicPath = path.join(__dirname, '..', 'public');
	app.use(express.static(publicPath));

	// Rate Limiter
	const apiLimiter = rateLimit({
		windowMs: 15 * 60 * 1000, // 15 minutes
		max: 1000, // Limit each IP to 1000 requests per window
		standardHeaders: true,
		legacyHeaders: false,
	});

	app.use('/api/', apiLimiter);

	// Strict rate limiter for setup routes (unauthenticated)
	const setupLimiter = rateLimit({
		windowMs: 15 * 60 * 1000, // 15 minutes
		max: 10, // Only 10 attempts per window
		standardHeaders: true,
		legacyHeaders: false,
	});
	// Strict authentication rate limiter to prevent brute-force attacks
	const authLimiter = rateLimit({ windowMs: 15 * 60 * 1000, max: 10 });

	app.use('/api/setup', setupLimiter, createSetupRouter(setupController)); // Setup route (no auth required)
	app.use('/api/user', createUserRouter(userController, authLimiter));
	app.use('/api/plans', createPlanRouter(planController));
	app.use('/api/backups', createBackupRouter(backupController));
	app.use('/api/devices', createDeviceRouter(deviceController));
	app.use('/api/storages', createStorageRouter(storageController));
	app.use('/api/restores', createRestoreRouter(restoreController));
	app.use('/api/settings', createSettingsRouter(settingsController));
	app.use('/api/health', createHealthRouter());

	// For any other request that doesn't match an API route or a static file,
	// serve the index.html file. This is the key for Single Page Applications.
	app.get('{*path}', (req, res) => {
		res.sendFile(path.join(publicPath, 'index.html'));
	});

	// Clean up backups/restores left "in progress" by a previous shutdown, before any schedule job starts.
	await new StartupRecovery(planService).run();

	// Reconcile CronManager schedules with the database (fixes drift on restart)
	try {
		await planService.reconcileSchedules();
	} catch (error: any) {
		console.error('[Startup] Schedule reconciliation failed:', error?.message);
	}

	// Start System task schedules
	const systemTaskManager = SystemTaskManager.getInstance(SYSTEM_JOBS);
	systemTaskManager.initialize();

	// Start Backup Job Schedules
	jobProcessor.registerTasks({
		backupManager: localPlanAgent,
		restoreManager: localRestoreAgent,
	});

	// Self Backup Task
	jobProcessor.addTask(new SelfBackupTask(selfBackupService));

	jobProcessor.start();

	return { app };
}