feat(ui): add structured JSON logging to all server-side routes and lib

Introduces a logger.ts module emitting slog-compatible JSON lines to stderr.
Replaces silent catch blocks and console.error calls throughout minio.ts,
pocketbase.ts, hooks.server.ts, login, books, browse, and all API routes so
auth/registration failures, MinIO presign errors, and scraper proxy failures
are now visible in container logs.

ui/src/lib/server/logger.ts

@@ -0,0 +1,37 @@
+/**
+ * Structured server-side logger.
+ *
+ * Emits JSON lines to stderr so they appear in container/process logs without
+ * polluting stdout (which Node's HTTP layer uses for responses).
+ *
+ * Format mirrors Go's log/slog default JSON output:
+ *   {"time":"…","level":"ERROR","msg":"…","context":"pocketbase",...extra}
+ *
+ * Usage:
+ *   import { log } from '$lib/server/logger';
+ *   log.error('pocketbase', 'auth failed', { status: 401, url });
+ *   log.warn('minio', 'presign slow', { slug, n, ms: elapsed });
+ *   log.info('auth', 'user registered', { username });
+ */
+
+type Level = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+type Extra = Record<string, unknown>;
+
+function emit(level: Level, context: string, msg: string, extra?: Extra): void {
+	const entry: Record<string, unknown> = {
+		time: new Date().toISOString(),
+		level,
+		context,
+		msg,
+		...extra
+	};
+	// Write to stderr — never stdout
+	process.stderr.write(JSON.stringify(entry) + '\n');
+}
+
+export const log = {
+	debug: (context: string, msg: string, extra?: Extra) => emit('DEBUG', context, msg, extra),
+	info:  (context: string, msg: string, extra?: Extra) => emit('INFO',  context, msg, extra),
+	warn:  (context: string, msg: string, extra?: Extra) => emit('WARN',  context, msg, extra),
+	error: (context: string, msg: string, extra?: Extra) => emit('ERROR', context, msg, extra),
+};

ui/src/lib/server/minio.ts

@@ -8,6 +8,7 @@
 
 import { env } from '$env/dynamic/private';
 import { env as pubEnv } from '$env/dynamic/public';
+import { log } from '$lib/server/logger';
 
 const SCRAPER_URL = env.SCRAPER_API_URL ?? 'http://localhost:8080';
 // Public MinIO URL — used to rewrite presigned URLs so the browser can reach MinIO directly.
@@ -40,9 +41,21 @@ function rewriteHost(presignedUrl: string): string {
  * server-side (in a +page.server.ts load function) to fetch the markdown content.
  */
 export async function presignChapter(slug: string, n: number): Promise<string> {
-	const res = await fetch(`${SCRAPER_URL}/api/presign/chapter/${slug}/${n}`);
-	if (!res.ok) throw new Error(`presign chapter ${slug}/${n}: ${res.status}`);
+	log.debug('minio', 'presigning chapter', { slug, n });
+	let res: Response;
+	try {
+		res = await fetch(`${SCRAPER_URL}/api/presign/chapter/${slug}/${n}`);
+	} catch (e) {
+		log.error('minio', 'presign chapter network error', { slug, n, err: String(e) });
+		throw new Error(`presign chapter ${slug}/${n}: network error`);
+	}
+	if (!res.ok) {
+		const body = await res.text().catch(() => '');
+		log.error('minio', 'presign chapter failed', { slug, n, status: res.status, body });
+		throw new Error(`presign chapter ${slug}/${n}: ${res.status}`);
+	}
 	const data = (await res.json()) as { url: string };
+	log.debug('minio', 'presign chapter ok', { slug, n });
 	return rewriteHost(data.url);
 }
 
@@ -60,8 +73,20 @@ export async function presignAudio(
 	if (voice) params.set('voice', voice);
 	if (speed) params.set('speed', String(speed));
 	const qs = params.toString() ? `?${params.toString()}` : '';
-	const res = await fetch(`${SCRAPER_URL}/api/presign/audio/${slug}/${n}${qs}`);
-	if (!res.ok) throw new Error(`presign audio ${slug}/${n}: ${res.status}`);
+	log.debug('minio', 'presigning audio', { slug, n, voice, speed });
+	let res: Response;
+	try {
+		res = await fetch(`${SCRAPER_URL}/api/presign/audio/${slug}/${n}${qs}`);
+	} catch (e) {
+		log.error('minio', 'presign audio network error', { slug, n, err: String(e) });
+		throw new Error(`presign audio ${slug}/${n}: network error`);
+	}
+	if (!res.ok) {
+		const body = await res.text().catch(() => '');
+		log.error('minio', 'presign audio failed', { slug, n, status: res.status, body });
+		throw new Error(`presign audio ${slug}/${n}: ${res.status}`);
+	}
 	const data = (await res.json()) as { url: string };
+	log.debug('minio', 'presign audio ok', { slug, n });
 	return rewriteHost(data.url);
 }

ui/src/lib/server/pocketbase.ts

@@ -5,6 +5,7 @@
  */
 
 import { env } from '$env/dynamic/private';
+import { log } from '$lib/server/logger';
 
 const PB_URL = env.POCKETBASE_URL ?? 'http://localhost:8090';
 const PB_EMAIL = env.POCKETBASE_ADMIN_EMAIL ?? 'admin@libnovel.local';
@@ -58,6 +59,8 @@ let _tokenExp = 0;
 async function getToken(): Promise<string> {
 	if (_token && Date.now() < _tokenExp) return _token;
 
+	log.debug('pocketbase', 'authenticating with admin credentials', { url: PB_URL, email: PB_EMAIL });
+
 	const res = await fetch(`${PB_URL}/api/admins/auth-with-password`, {
 		method: 'POST',
 		headers: { 'Content-Type': 'application/json' },
@@ -65,12 +68,15 @@ async function getToken(): Promise<string> {
 	});
 
 	if (!res.ok) {
-		throw new Error(`PocketBase auth failed: ${res.status}`);
+		const body = await res.text().catch(() => '');
+		log.error('pocketbase', 'admin auth failed', { status: res.status, url: PB_URL, body });
+		throw new Error(`PocketBase auth failed: ${res.status} — ${body}`);
 	}
 
 	const data = await res.json();
 	_token = data.token as string;
 	_tokenExp = Date.now() + 12 * 60 * 60 * 1000; // 12 hours
+	log.info('pocketbase', 'admin auth token refreshed', { url: PB_URL });
 	return _token;
 }
 
@@ -81,7 +87,11 @@ async function pbGet<T>(path: string): Promise<T> {
 	const res = await fetch(`${PB_URL}${path}`, {
 		headers: { Authorization: token }
 	});
-	if (!res.ok) throw new Error(`PocketBase GET ${path} failed: ${res.status}`);
+	if (!res.ok) {
+		const body = await res.text().catch(() => '');
+		log.error('pocketbase', 'GET failed', { path, status: res.status, body });
+		throw new Error(`PocketBase GET ${path} failed: ${res.status} — ${body}`);
+	}
 	return res.json() as Promise<T>;
 }
 
@@ -103,10 +113,6 @@ async function pbPatch(path: string, body: unknown): Promise<Response> {
 	});
 }
 
-function encodeFilter(filter: string) {
-	return encodeURIComponent(filter);
-}
-
 interface PBList<T> {
 	items: T[];
 	totalItems: number;
@@ -170,9 +176,17 @@ export async function setProgress(sessionId: string, slug: string, chapter: numb
 	};
 
 	if (existing) {
-		await pbPatch(`/api/collections/progress/records/${existing.id}`, payload);
+		const res = await pbPatch(`/api/collections/progress/records/${existing.id}`, payload);
+		if (!res.ok) {
+			const body = await res.text().catch(() => '');
+			log.error('pocketbase', 'setProgress PATCH failed', { slug, chapter, status: res.status, body });
+		}
 	} else {
-		await pbPost('/api/collections/progress/records', payload);
+		const res = await pbPost('/api/collections/progress/records', payload);
+		if (!res.ok) {
+			const body = await res.text().catch(() => '');
+			log.error('pocketbase', 'setProgress POST failed', { slug, chapter, status: res.status, body });
+		}
 	}
 }
 
@@ -206,11 +220,14 @@ export async function getUserByUsername(username: string): Promise<User | null>
  * Create a new user with a hashed password. Throws if username already exists.
  */
 export async function createUser(username: string, password: string, role = 'user'): Promise<User> {
+	log.info('pocketbase', 'createUser: checking for existing username', { username });
 	const existing = await getUserByUsername(username);
 	if (existing) {
+		log.warn('pocketbase', 'createUser: username already taken', { username });
 		throw new Error('Username already taken');
 	}
 	const password_hash = hashPassword(password);
+	log.info('pocketbase', 'createUser: inserting new user', { username, role });
 	const res = await pbPost('/api/collections/users/records', {
 		username,
 		password_hash,
@@ -218,21 +235,33 @@ export async function createUser(username: string, password: string, role = 'use
 		created: new Date().toISOString()
 	});
 	if (!res.ok) {
-		const body = await res.text();
+		const body = await res.text().catch(() => '');
+		log.error('pocketbase', 'createUser: PocketBase rejected record', {
+			username,
+			status: res.status,
+			body
+		});
 		throw new Error(`Failed to create user: ${res.status} ${body}`);
 	}
+	log.info('pocketbase', 'createUser: user created', { username, role });
 	return res.json() as Promise<User>;
 }
 
 /**
  * Verify username + password. Returns the user on success, null on failure.
  */
-export async function loginUser(
-	username: string,
-	password: string
-): Promise<User | null> {
+export async function loginUser(username: string, password: string): Promise<User | null> {
+	log.debug('pocketbase', 'loginUser: lookup', { username });
 	const user = await getUserByUsername(username);
-	if (!user) return null;
-	if (!verifyPassword(password, user.password_hash)) return null;
+	if (!user) {
+		log.warn('pocketbase', 'loginUser: username not found', { username });
+		return null;
+	}
+	const ok = verifyPassword(password, user.password_hash);
+	if (!ok) {
+		log.warn('pocketbase', 'loginUser: wrong password', { username });
+		return null;
+	}
+	log.info('pocketbase', 'loginUser: success', { username, role: user.role });
 	return user;
 }