feat(app): wire config, singleton app bootstrap, and auth hooks

.env.example

@@ -5,4 +5,5 @@ CURRENCY=USD
 # Only for STORAGE=hf:
 # HF_TOKEN=hf_xxx
 # HF_BUCKET=buckets/assafvayner/splitwise-data
+# HF_PREFIX=prod
 # COMPACTION_INTERVAL_MS=3600000

src/hooks.server.ts

@@ -0,0 +1,44 @@
+import { dev } from '$app/environment';
+import { SESSION_COOKIE, verifySessionToken } from '$lib/server/auth/session';
+import { getApp } from '$lib/server/app';
+import { error, redirect, type Handle } from '@sveltejs/kit';
+
+const PUBLIC_PATHS = new Set(['/login']);
+const ALLOWED_WHILE_PASSWORD_CHANGE = new Set(['/me/password', '/logout']);
+
+export const handle: Handle = async ({ event, resolve }) => {
+	const app = await getApp();
+	event.locals.app = app;
+	event.locals.user = null;
+
+	const token = event.cookies.get(SESSION_COOKIE);
+	if (token) {
+		const payload = verifySessionToken(token, app.config.sessionSecret);
+		const user = payload ? app.users.byId(payload.uid) : undefined;
+		if (payload && user && user.active && user.sessionVersion === payload.sv) {
+			event.locals.user = user;
+		} else {
+			event.cookies.delete(SESSION_COOKIE, { path: '/' });
+		}
+	}
+
+	const path = event.url.pathname;
+	const user = event.locals.user;
+
+	if (!user) {
+		if (!PUBLIC_PATHS.has(path)) redirect(303, `/login?next=${encodeURIComponent(path)}`);
+	} else {
+		if (path === '/login') redirect(303, '/');
+		if (user.mustChangePassword && !ALLOWED_WHILE_PASSWORD_CHANGE.has(path)) redirect(303, '/me/password');
+		if (path.startsWith('/admin') && user.role !== 'admin') error(403, 'Admins only');
+		if (event.request.method !== 'GET' && event.request.method !== 'HEAD' && path !== '/logout') {
+			app.ledger.readOnly = !app.guard.canWrite;
+			if (!app.guard.canWrite)
+				error(503, 'Read-only: another instance of the app is currently active. Try again in a couple of minutes.');
+		}
+	}
+
+	const response = await resolve(event);
+	if (!dev) response.headers.set('X-Frame-Options', 'DENY');
+	return response;
+};

src/lib/server/app.ts

@@ -1,3 +1,99 @@
+import { randomUUID } from 'node:crypto';
+import { RateLimiter } from './auth/rate-limit';
+import { loadConfig, type Config } from './config';
+import { Ledger, type CompactionResult } from './ledger/ledger';
+import { WriterGuard } from './ledger/writer-guard';
+import { HfBucketStore } from './storage/hf-bucket-store';
+import { LocalFsStore } from './storage/local-fs-store';
+import { PrefixedStore } from './storage/prefixed-store';
+import type { BucketStore } from './storage/store';
+import { UsersRepo } from './users/repository';
+
+export interface CompactionStatus {
+	lastRunAt: string | null;
+	lastResult: CompactionResult | null;
+	lastError: string | null;
+	running: boolean;
+}
+
 export interface App {
-	placeholder: true;
+	config: Config;
+	store: BucketStore;
+	users: UsersRepo;
+	ledger: Ledger;
+	guard: WriterGuard;
+	loginLimiter: RateLimiter;
+	compaction: CompactionStatus;
+	runCompaction(): Promise<CompactionResult>;
+}
+
+let instance: Promise<App> | null = null;
+
+/** Builds the singleton on first call; subsequent calls return the same promise. */
+export function getApp(): Promise<App> {
+	instance ??= build().catch((e) => {
+		instance = null;
+		throw e;
+	});
+	return instance;
+}
+
+async function build(): Promise<App> {
+	const config = loadConfig();
+	const base: BucketStore =
+		config.storage === 'hf' ? new HfBucketStore(config.hfBucket, config.hfToken) : new LocalFsStore(config.localDataDir);
+	const store: BucketStore = config.hfPrefix ? new PrefixedStore(base, config.hfPrefix) : base;
+	console.log(
+		`[app] storage=${config.storage}${config.storage === 'hf' ? ` bucket=${config.hfBucket}` : ` dir=${config.localDataDir}`}${config.hfPrefix ? ` prefix=${config.hfPrefix}/` : ''}`
+	);
+
+	const users = await UsersRepo.load(store);
+	const guard = new WriterGuard(store, randomUUID());
+	const acquired = await guard.acquire();
+	if (!acquired) console.error('[app] another instance holds the writer lock; starting READ-ONLY until it goes stale');
+	guard.start();
+
+	const ledger = await Ledger.load(store);
+	ledger.readOnly = !guard.canWrite;
+
+	const compaction: CompactionStatus = { lastRunAt: null, lastResult: null, lastError: null, running: false };
+	const app: App = {
+		config,
+		store,
+		users,
+		ledger,
+		guard,
+		loginLimiter: new RateLimiter(5, 60_000),
+		compaction,
+		async runCompaction() {
+			compaction.running = true;
+			try {
+				const result = await ledger.compact();
+				compaction.lastResult = result;
+				compaction.lastError = null;
+				return result;
+			} catch (e) {
+				compaction.lastError = e instanceof Error ? e.message : String(e);
+				throw e;
+			} finally {
+				compaction.running = false;
+				compaction.lastRunAt = new Date().toISOString();
+			}
+		}
+	};
+
+	const timer = setInterval(() => {
+		ledger.readOnly = !guard.canWrite;
+		if (ledger.readOnly) return;
+		app.runCompaction().catch((e) => console.error('[compaction] failed', e));
+	}, config.compactionIntervalMs);
+	timer.unref?.();
+
+	if (guard.canWrite && ledger.stats().pendingEvents > 0) {
+		app.runCompaction().catch((e) => console.error('[compaction] boot compaction failed', e));
+	}
+	console.log(
+		`[app] ready: ${users.all().length} users, ${ledger.listExpenses().length} expenses, ${ledger.stats().pendingEvents} pending events`
+	);
+	return app;
 }

src/lib/server/config.ts

@@ -0,0 +1,37 @@
+import { env } from '$env/dynamic/private';
+import { dev } from '$app/environment';
+
+export interface Config {
+	storage: 'local' | 'hf';
+	hfToken: string;
+	hfBucket: `buckets/${string}`;
+	/** Directory inside the bucket that this deployment owns; '' means the bucket root. */
+	hfPrefix: string;
+	localDataDir: string;
+	sessionSecret: string;
+	currency: string;
+	compactionIntervalMs: number;
+}
+
+function required(name: string, value: string | undefined): string {
+	if (!value) throw new Error(`Missing required environment variable ${name}`);
+	return value;
+}
+
+export function loadConfig(): Config {
+	const storage = (env.STORAGE ?? (dev ? 'local' : 'hf')) as Config['storage'];
+	if (storage !== 'local' && storage !== 'hf') throw new Error(`STORAGE must be 'local' or 'hf', got '${storage}'`);
+	const sessionSecret = env.SESSION_SECRET ?? (dev ? 'dev-only-session-secret-do-not-use-in-prod' : undefined);
+	const hfBucket = storage === 'hf' ? required('HF_BUCKET', env.HF_BUCKET) : '';
+	if (storage === 'hf' && !hfBucket.startsWith('buckets/')) throw new Error('HF_BUCKET must look like buckets/<namespace>/<name>');
+	return {
+		storage,
+		hfToken: storage === 'hf' ? required('HF_TOKEN', env.HF_TOKEN) : '',
+		hfBucket: hfBucket as `buckets/${string}`,
+		hfPrefix: (env.HF_PREFIX ?? '').replace(/^\/+|\/+$/g, ''),
+		localDataDir: env.LOCAL_DATA_DIR ?? '.data',
+		sessionSecret: required('SESSION_SECRET', sessionSecret),
+		currency: env.CURRENCY ?? 'USD',
+		compactionIntervalMs: Number(env.COMPACTION_INTERVAL_MS ?? 3_600_000)
+	};
+}