jukebox-media-server 0.3.0 → 0.4.0

package/dist/server/index.js

@@ -9,9 +9,9 @@ import { versions } from "process";
 import Database from "better-sqlite3";
 import crypto$2 from "node:crypto";
 import fs from "node:fs";
-import { access, readFile, readdir, stat, writeFile } from "fs/promises";
 import os, { homedir } from "os";
 import { promisify } from "util";
+import { access, readFile, readdir, stat } from "fs/promises";
 import { EventEmitter } from "node:events";
 import process$1 from "node:process";
 import os$1 from "node:os";
@@ -6789,24 +6789,11 @@ function migrate(db, config) {
 //#endregion
 //#region src/config/index.ts
 const configDirectory = join(homedir(), ".jukebox");
-const configFilePath = join(configDirectory, "config.json");
+join(configDirectory, "config.json");
 const databasePath = join(configDirectory, "jukebox.db");
 function ensureConfigDirectory() {
 	mkdirSync(configDirectory, { recursive: true });
 }
-function getConfig() {
-	if (!existsSync(configFilePath)) return null;
-	try {
-		const raw = readFileSync(configFilePath, "utf-8");
-		return JSON.parse(raw);
-	} catch {
-		return null;
-	}
-}
-async function saveConfig(config) {
-	ensureConfigDirectory();
-	await writeFile(configFilePath, JSON.stringify(config, null, 2));
-}
 //#endregion
 //#region src/database/schema.ts
 var schema_exports = /* @__PURE__ */ __exportAll({
@@ -6846,27 +6833,27 @@ const movies = sqliteTable("movies", {
 	extension: text("extension"),
 	createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
 	updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
-	tmdbId: integer("tmdb_id"),
+	externalId: text("external_id"),
 	year: integer("year"),
 	overview: text("overview"),
 	runtime: integer("runtime"),
 	genres: text("genres"),
 	rating: real("rating"),
-	posterPath: text("poster_path"),
-	backdropPath: text("backdrop_path"),
+	posterUrl: text("poster_url"),
+	backdropUrl: text("backdrop_url"),
 	trailerUrl: text("trailer_url")
 });
 const shows = sqliteTable("shows", {
 	id: integer("id").primaryKey({ autoIncrement: true }),
 	title: text("title").notNull(),
 	folderPath: text("folder_path").notNull().unique(),
-	tmdbId: integer("tmdb_id"),
+	externalId: text("external_id"),
 	year: integer("year"),
 	overview: text("overview"),
 	genres: text("genres"),
 	rating: real("rating"),
-	posterPath: text("poster_path"),
-	backdropPath: text("backdrop_path"),
+	posterUrl: text("poster_url"),
+	backdropUrl: text("backdrop_url"),
 	createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
 	updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
 });
@@ -6876,7 +6863,7 @@ const seasons = sqliteTable("seasons", {
 	seasonNumber: integer("season_number").notNull(),
 	name: text("name"),
 	overview: text("overview"),
-	posterPath: text("poster_path"),
+	posterUrl: text("poster_url"),
 	episodeCount: integer("episode_count")
 });
 const episodes = sqliteTable("episodes", {
@@ -6890,10 +6877,10 @@ const episodes = sqliteTable("episodes", {
 	fileName: text("file_name").notNull(),
 	fileSize: integer("file_size"),
 	extension: text("extension"),
-	tmdbId: integer("tmdb_id"),
+	externalId: text("external_id"),
 	overview: text("overview"),
 	runtime: integer("runtime"),
-	stillPath: text("still_path"),
+	stillUrl: text("still_url"),
 	createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
 	updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
 });
@@ -7624,6 +7611,78 @@ episodeStreamRoutes.get("/:id", async (context) => {
 	} });
 });
 //#endregion
+//#region src/api/routes/filesystem.ts
+async function listWindowsDrives() {
+	const letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("");
+	const drives = [];
+	await Promise.all(letters.map(async (letter) => {
+		const drivePath = `${letter}:\\`;
+		try {
+			await access(drivePath, constants.R_OK);
+			drives.push({
+				name: `${letter}:`,
+				path: drivePath
+			});
+		} catch {}
+	}));
+	drives.sort((a, b) => a.name.localeCompare(b.name));
+	return drives;
+}
+function listPosixRoots() {
+	const entries = [{
+		name: "/",
+		path: "/"
+	}];
+	const home = homedir();
+	if (home && home !== "/") entries.push({
+		name: `Home (${home})`,
+		path: home
+	});
+	return entries;
+}
+async function listRoots() {
+	return {
+		entries: process.platform === "win32" ? await listWindowsDrives() : listPosixRoots(),
+		parent: null,
+		path: "",
+		separator: path.sep
+	};
+}
+function isAtFilesystemRoot(resolved) {
+	return path.dirname(resolved) === resolved;
+}
+async function listDirectory(inputPath) {
+	const resolved = path.resolve(inputPath);
+	return {
+		entries: (await readdir(resolved, { withFileTypes: true })).filter((dirent) => dirent.isDirectory() && !dirent.name.startsWith(".")).map((dirent) => ({
+			name: dirent.name,
+			path: path.join(resolved, dirent.name)
+		})).sort((a, b) => a.name.localeCompare(b.name, void 0, { sensitivity: "base" })),
+		parent: isAtFilesystemRoot(resolved) ? null : path.dirname(resolved),
+		path: resolved,
+		separator: path.sep
+	};
+}
+const filesystemRoutes = new Hono();
+filesystemRoutes.get("/browse", async (context) => {
+	const rawPath = context.req.query("path");
+	const trimmed = typeof rawPath === "string" ? rawPath.trim() : "";
+	if (trimmed.length === 0) {
+		const response = await listRoots();
+		return context.json(response);
+	}
+	try {
+		const response = await listDirectory(trimmed);
+		return context.json(response);
+	} catch (caught) {
+		const code = caught && typeof caught === "object" && "code" in caught ? String(caught.code) : "unknown";
+		if (code === "ENOENT") return context.json({ error: { message: `Folder doesn't exist: ${trimmed}. Check the path and try again.` } }, 404);
+		if (code === "EACCES" || code === "EPERM") return context.json({ error: { message: `Jukebox doesn't have permission to read ${trimmed}. Check the server's file permissions.` } }, 403);
+		if (code === "ENOTDIR") return context.json({ error: { message: `${trimmed} is a file, not a folder. Pick a folder instead.` } }, 400);
+		return context.json({ error: { message: `Couldn't list ${trimmed}: ${code}.` } }, 500);
+	}
+});
+//#endregion
 //#region src/api/routes/hello.ts
 const helloRoutes = new Hono();
 helloRoutes.get("/", (c) => c.json({
@@ -7985,11 +8044,17 @@ progressRoutes.get("/continue-watching", async (context) => {
 		...result,
 		type: "movie"
 	}));
-	const episodes$2 = episodeResults.map((result) => ({
+	const episodesSorted = episodeResults.map((result) => ({
 		...result,
 		type: "episode"
-	}));
-	const combined = [...movies$2, ...episodes$2].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()).slice(0, 20);
+	})).sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+	const seenShowIds = /* @__PURE__ */ new Set();
+	const dedupedEpisodes = episodesSorted.filter((item) => {
+		if (seenShowIds.has(item.show.id)) return false;
+		seenShowIds.add(item.show.id);
+		return true;
+	});
+	const combined = [...movies$2, ...dedupedEpisodes].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()).slice(0, 20);
 	return context.json(combined);
 });
 progressRoutes.get("/:movieId", async (c) => {
@@ -8621,218 +8686,124 @@ var Logger = class {
 };
 var log = new Logger();
 //#endregion
-//#region src/services/settings.ts
-const tmdbApiKeySettingKey = "tmdbApiKey";
-const scanScheduleSettingKey = "scanSchedule";
-const scanScheduleValues = [
-	"off",
-	"6h",
-	"12h",
-	"24h"
-];
-function isScanScheduleValue(value) {
-	return scanScheduleValues.includes(value);
+//#region src/services/metadata.ts
+const defaultApiBaseUrl = "https://movie-data-api.artgaard.workers.dev";
+function getApiBaseUrl() {
+	const fromEnv = process.env.JUKEBOX_METADATA_API_URL?.trim();
+	if (fromEnv !== void 0 && fromEnv.length > 0) return fromEnv.replace(/\/+$/, "");
+	return defaultApiBaseUrl;
+}
+async function apiGet(path) {
+	const response = await fetch(`${getApiBaseUrl()}${path}`);
+	if (response.status === 404) throw new NotFoundError(path);
+	if (!response.ok) throw new Error(`Metadata API request failed with status ${response.status} for ${path}`);
+	return await response.json();
 }
-/**
-* Read a setting value from the DB. Returns null when the key is not set.
-*
-* Accepts an optional database instance so tests and scripts can pass an
-* in-memory SQLite instance instead of the singleton.
-*/
-async function getSetting(key, database = db) {
-	const [row] = await database.select().from(settings).where(eq(settings.key, key)).limit(1);
-	return row?.value ?? null;
+var NotFoundError = class extends Error {
+	constructor(path) {
+		super(`Metadata API returned 404 for ${path}`);
+		this.name = "NotFoundError";
+	}
+};
+function mapMovie(apiMovie) {
+	return {
+		externalId: apiMovie.id,
+		title: apiMovie.title,
+		year: apiMovie.year,
+		overview: apiMovie.overview,
+		runtime: apiMovie.runtime,
+		genres: JSON.stringify(apiMovie.genres),
+		rating: apiMovie.rating,
+		posterUrl: apiMovie.posterUrl,
+		backdropUrl: apiMovie.backdropUrl,
+		trailerUrl: apiMovie.trailerUrl
+	};
 }
-/**
-* Upsert a setting value.
-*
-* Uses a single INSERT ... ON CONFLICT so two concurrent callers don't both
-* read null, both INSERT, and fail with a UNIQUE constraint on the second.
-*/
-async function setSetting(key, value, database = db) {
-	const now = Date.now();
-	await database.insert(settings).values({
-		key,
-		value,
-		updatedAt: now
-	}).onConflictDoUpdate({
-		target: settings.key,
-		set: {
-			value,
-			updatedAt: now
-		}
-	});
+function mapShow(apiShow) {
+	return {
+		externalId: apiShow.id,
+		title: apiShow.title,
+		year: apiShow.year,
+		overview: apiShow.overview,
+		genres: JSON.stringify(apiShow.genres),
+		rating: apiShow.rating,
+		posterUrl: apiShow.posterUrl,
+		backdropUrl: apiShow.backdropUrl,
+		numberOfSeasons: apiShow.numberOfSeasons
+	};
 }
-/**
-* Resolve the TMDB API key using the dual-source strategy:
-*
-* 1. Prefer the value stored in the `settings` table.
-* 2. Fall back to `~/.jukebox/config.json` for backward compatibility on the
-*    first boot after upgrading. Copy the JSON value into the DB once so
-*    subsequent lookups only touch the DB.
-*
-* Returns null when neither source has a key configured.
-*/
-async function getTmdbApiKey(database = db) {
-	const stored = await getSetting(tmdbApiKeySettingKey, database);
-	if (stored !== null && stored.length > 0) return stored;
-	const legacyKey = getConfig()?.tmdbApiKey ?? null;
-	if (legacyKey !== null && legacyKey.length > 0) {
-		await setSetting(tmdbApiKeySettingKey, legacyKey, database);
-		return legacyKey;
-	}
-	return null;
+function mapSeason(apiSeason) {
+	return {
+		seasonNumber: apiSeason.seasonNumber,
+		name: apiSeason.name,
+		overview: apiSeason.overview,
+		posterUrl: apiSeason.posterUrl,
+		episodes: apiSeason.episodes.map((episode) => ({
+			episodeNumber: episode.episodeNumber,
+			title: episode.title,
+			overview: episode.overview,
+			runtime: episode.runtime,
+			stillUrl: episode.stillUrl
+		}))
+	};
 }
-/**
-* Persist the TMDB API key to the DB. Also mirror the value to the JSON
-* config file so rollbacks to an older server build keep working.
-*/
-async function setTmdbApiKey(apiKey, database = db) {
-	await setSetting(tmdbApiKeySettingKey, apiKey, database);
+async function fetchMovieMetadata(title, year) {
 	try {
-		await saveConfig({ tmdbApiKey: apiKey });
-	} catch (error) {
-		log.warn("Couldn't mirror TMDB key to config.json — rollback safety is degraded. Check permissions on ~/.jukebox/.", error);
+		const search = new URLSearchParams({ title });
+		if (year !== void 0) search.set("year", year.toString());
+		const { results } = await apiGet(`/movies/search?${search.toString()}`);
+		const bestMatch = results[0];
+		if (!bestMatch) return null;
+		return mapMovie(bestMatch);
+	} catch (caughtError) {
+		const message = caughtError instanceof Error ? caughtError.message : "Unknown error";
+		log.warn(`Metadata lookup for movie "${title}" (${year ?? "no year"}) failed — continuing without metadata: ${message}`);
+		return null;
 	}
 }
-//#endregion
-//#region src/services/tmdb.ts
-const tmdbBaseUrl = "https://api.themoviedb.org/3";
-async function getApiKey() {
-	const apiKey = await getTmdbApiKey() ?? process.env.TMDB_API_KEY ?? null;
-	if (!apiKey) throw new Error("TMDB API key is not configured");
-	return apiKey;
-}
-async function searchMovie(title, year) {
-	const apiKey = await getApiKey();
-	const params = new URLSearchParams({
-		api_key: apiKey,
-		query: title
-	});
-	if (year) params.set("year", year.toString());
-	const response = await fetch(`${tmdbBaseUrl}/search/movie?${params.toString()}`);
-	if (!response.ok) throw new Error(`TMDB search failed: ${response.statusText}`);
-	return (await response.json()).results;
-}
-async function getMovieDetails(tmdbId) {
-	const apiKey = await getApiKey();
-	const params = new URLSearchParams({ api_key: apiKey });
-	const response = await fetch(`${tmdbBaseUrl}/movie/${tmdbId}?${params.toString()}`);
-	if (!response.ok) throw new Error(`TMDB movie details failed: ${response.statusText}`);
-	return await response.json();
-}
-async function getMovieVideos(tmdbId) {
-	const apiKey = await getApiKey();
-	const params = new URLSearchParams({ api_key: apiKey });
-	const response = await fetch(`${tmdbBaseUrl}/movie/${tmdbId}/videos?${params.toString()}`);
-	if (!response.ok) throw new Error(`TMDB movie videos failed: ${response.statusText}`);
-	return (await response.json()).results;
-}
-function getTrailerUrl(videos) {
-	const youtubeVideos = videos.filter((v) => v.site === "YouTube");
-	for (const type of [
-		"Trailer",
-		"Teaser",
-		"Clip"
-	]) {
-		const video = youtubeVideos.find((v) => v.type === type);
-		if (video) return `https://www.youtube.com/watch?v=${video.key}`;
+async function fetchMovieByExternalId(externalId) {
+	try {
+		return mapMovie(await apiGet(`/movies/${encodeURIComponent(externalId)}`));
+	} catch (caughtError) {
+		if (caughtError instanceof NotFoundError) return null;
+		const message = caughtError instanceof Error ? caughtError.message : "Unknown error";
+		log.warn(`Metadata lookup for movie id=${externalId} failed — continuing without metadata: ${message}`);
+		return null;
 	}
-	if (youtubeVideos.length > 0 && youtubeVideos[0]) return `https://www.youtube.com/watch?v=${youtubeVideos[0].key}`;
-	return null;
 }
-async function fetchMovieMetadata(title, year) {
+async function fetchShowByExternalId(externalId) {
 	try {
-		await getApiKey();
-	} catch {
+		return mapShow(await apiGet(`/shows/${encodeURIComponent(externalId)}`));
+	} catch (caughtError) {
+		if (caughtError instanceof NotFoundError) return null;
+		const message = caughtError instanceof Error ? caughtError.message : "Unknown error";
+		log.warn(`Metadata lookup for show id=${externalId} failed — continuing without metadata: ${message}`);
 		return null;
 	}
-	const results = await searchMovie(title, year);
-	if (results.length === 0 || !results[0]) return null;
-	const bestMatch = results[0];
-	const [details, videos] = await Promise.all([getMovieDetails(bestMatch.id), getMovieVideos(bestMatch.id)]);
-	const releaseYear = details.release_date ? parseInt(details.release_date.split("-")[0] ?? "0", 10) || null : null;
-	return {
-		tmdbId: details.id,
-		title: details.title,
-		year: releaseYear,
-		overview: details.overview,
-		runtime: details.runtime,
-		genres: JSON.stringify(details.genres.map((g) => g.name)),
-		rating: details.vote_average,
-		posterPath: details.poster_path,
-		backdropPath: details.backdrop_path,
-		trailerUrl: getTrailerUrl(videos)
-	};
-}
-async function searchShow(title, year) {
-	const apiKey = await getApiKey();
-	const params = new URLSearchParams({
-		api_key: apiKey,
-		query: title
-	});
-	if (year) params.set("first_air_date_year", year.toString());
-	const response = await fetch(`${tmdbBaseUrl}/search/tv?${params.toString()}`);
-	if (!response.ok) throw new Error(`TMDB TV search failed: ${response.statusText}`);
-	return (await response.json()).results;
-}
-async function getShowDetails(tmdbId) {
-	const apiKey = await getApiKey();
-	const params = new URLSearchParams({ api_key: apiKey });
-	const response = await fetch(`${tmdbBaseUrl}/tv/${tmdbId}?${params.toString()}`);
-	if (!response.ok) throw new Error(`TMDB show details failed: ${response.statusText}`);
-	return await response.json();
-}
-async function getSeasonDetails(tmdbId, seasonNumber) {
-	const apiKey = await getApiKey();
-	const params = new URLSearchParams({ api_key: apiKey });
-	const response = await fetch(`${tmdbBaseUrl}/tv/${tmdbId}/season/${seasonNumber}?${params.toString()}`);
-	if (!response.ok) throw new Error(`TMDB season details failed: ${response.statusText}`);
-	return await response.json();
 }
 async function fetchShowMetadata(title, year) {
 	try {
-		await getApiKey();
-	} catch {
+		const search = new URLSearchParams({ title });
+		if (year !== void 0) search.set("year", year.toString());
+		const { results } = await apiGet(`/shows/search?${search.toString()}`);
+		const bestMatch = results[0];
+		if (!bestMatch) return null;
+		return mapShow(bestMatch);
+	} catch (caughtError) {
+		const message = caughtError instanceof Error ? caughtError.message : "Unknown error";
+		log.warn(`Metadata lookup for show "${title}" (${year ?? "no year"}) failed — continuing without metadata: ${message}`);
 		return null;
 	}
-	const results = await searchShow(title, year);
-	if (results.length === 0 || !results[0]) return null;
-	const bestMatch = results[0];
-	const details = await getShowDetails(bestMatch.id);
-	const firstAirYear = details.first_air_date ? parseInt(details.first_air_date.split("-")[0] ?? "0", 10) || null : null;
-	return {
-		tmdbId: details.id,
-		title: details.name,
-		year: firstAirYear,
-		overview: details.overview,
-		genres: JSON.stringify(details.genres.map((g) => g.name)),
-		rating: details.vote_average,
-		posterPath: details.poster_path,
-		backdropPath: details.backdrop_path,
-		numberOfSeasons: details.number_of_seasons
-	};
 }
-async function fetchSeasonMetadata(tmdbId, seasonNumber) {
+async function fetchSeasonMetadata(externalId, seasonNumber) {
 	try {
-		await getApiKey();
-	} catch {
+		return mapSeason(await apiGet(`/shows/${encodeURIComponent(externalId)}/seasons/${seasonNumber}`));
+	} catch (caughtError) {
+		if (caughtError instanceof NotFoundError) return null;
+		const message = caughtError instanceof Error ? caughtError.message : "Unknown error";
+		log.warn(`Metadata lookup for show id=${externalId} season=${seasonNumber} failed — continuing without metadata: ${message}`);
 		return null;
 	}
-	const details = await getSeasonDetails(tmdbId, seasonNumber);
-	return {
-		seasonNumber: details.season_number,
-		name: details.name,
-		overview: details.overview,
-		posterPath: details.poster_path,
-		episodes: details.episodes.map((episode) => ({
-			episodeNumber: episode.episode_number,
-			title: episode.name,
-			overview: episode.overview,
-			runtime: episode.runtime,
-			stillPath: episode.still_path
-		}))
-	};
 }
 //#endregion
 //#region src/services/subtitle-sync.ts
@@ -8918,35 +8889,42 @@ async function scanLibrary(libraryPath, onProgress) {
 		if (existing.length > 0 && existing[0]) {
 			const movie = existing[0];
 			movieId = movie.id;
-			let tmdbData = {};
-			if (!movie.tmdbId) {
-				console.log(`  Fetching TMDB metadata for: ${title}`);
+			let metadataUpdate = {};
+			if (!movie.externalId) {
+				console.log(`  Fetching metadata for: ${title}`);
 				const metadata = await fetchMovieMetadata(title, year ?? void 0);
-				if (metadata) tmdbData = {
-					tmdbId: metadata.tmdbId,
+				if (metadata) metadataUpdate = {
+					externalId: metadata.externalId,
 					year: metadata.year,
 					overview: metadata.overview,
 					runtime: metadata.runtime,
 					genres: metadata.genres,
 					rating: metadata.rating,
-					posterPath: metadata.posterPath,
-					backdropPath: metadata.backdropPath,
+					posterUrl: metadata.posterUrl,
+					backdropUrl: metadata.backdropUrl,
 					trailerUrl: metadata.trailerUrl
 				};
-			} else if (!movie.trailerUrl && movie.tmdbId) {
-				console.log(`  Fetching trailer for: ${movie.title}`);
-				try {
-					const trailerUrl = getTrailerUrl(await getMovieVideos(movie.tmdbId));
-					if (trailerUrl) tmdbData = { trailerUrl };
-				} catch {}
+			} else if (!movie.posterUrl || !movie.backdropUrl || !movie.trailerUrl) {
+				console.log(`  Refreshing metadata for: ${movie.title}`);
+				const refreshed = await fetchMovieByExternalId(movie.externalId);
+				if (refreshed) metadataUpdate = {
+					year: movie.year ?? refreshed.year,
+					overview: movie.overview ?? refreshed.overview,
+					runtime: movie.runtime ?? refreshed.runtime,
+					genres: movie.genres ?? refreshed.genres,
+					rating: movie.rating ?? refreshed.rating,
+					posterUrl: movie.posterUrl ?? refreshed.posterUrl,
+					backdropUrl: movie.backdropUrl ?? refreshed.backdropUrl,
+					trailerUrl: movie.trailerUrl ?? refreshed.trailerUrl
+				};
 			}
 			await db.update(movies).set({
-				title: movie.tmdbId ? movie.title : title,
+				title: movie.externalId ? movie.title : title,
 				fileName,
 				fileSize,
 				extension: ext,
 				updatedAt: now,
-				...tmdbData
+				...metadataUpdate
 			}).where(eq(movies.filePath, filePath));
 			updated++;
 			await onProgress?.({
@@ -8955,7 +8933,7 @@ async function scanLibrary(libraryPath, onProgress) {
 				updated
 			});
 		} else {
-			console.log(`  Fetching TMDB metadata for: ${title}`);
+			console.log(`  Fetching metadata for: ${title}`);
 			const metadata = await fetchMovieMetadata(title, year ?? void 0);
 			const newMovie = {
 				title: metadata?.title ?? title,
@@ -8965,14 +8943,14 @@ async function scanLibrary(libraryPath, onProgress) {
 				extension: ext,
 				createdAt: now,
 				updatedAt: now,
-				tmdbId: metadata?.tmdbId ?? null,
+				externalId: metadata?.externalId ?? null,
 				year: metadata?.year ?? year,
 				overview: metadata?.overview ?? null,
 				runtime: metadata?.runtime ?? null,
 				genres: metadata?.genres ?? null,
 				rating: metadata?.rating ?? null,
-				posterPath: metadata?.posterPath ?? null,
-				backdropPath: metadata?.backdropPath ?? null,
+				posterUrl: metadata?.posterUrl ?? null,
+				backdropUrl: metadata?.backdropUrl ?? null,
 				trailerUrl: metadata?.trailerUrl ?? null
 			};
 			movieId = (await db.insert(movies).values(newMovie).returning({ id: movies.id }))[0]?.id ?? null;
@@ -9236,29 +9214,43 @@ async function scanShowLibrary(libraryPath, onProgress) {
 		const folderPath = discoveredShow.folders[0] ?? "";
 		const existingShows = await db.select().from(shows).where(eq(shows.folderPath, folderPath)).limit(1);
 		let showId;
-		let tmdbId;
+		let externalId;
 		if (existingShows.length > 0 && existingShows[0]) {
-			showId = existingShows[0].id;
-			tmdbId = existingShows[0].tmdbId ?? null;
+			const existingShow = existingShows[0];
+			showId = existingShow.id;
+			externalId = existingShow.externalId ?? null;
+			if (externalId !== null && (!existingShow.posterUrl || !existingShow.backdropUrl || !existingShow.overview)) {
+				console.log(`  Refreshing metadata for show: ${existingShow.title}`);
+				const refreshed = await fetchShowByExternalId(externalId);
+				if (refreshed) await db.update(shows).set({
+					year: existingShow.year ?? refreshed.year,
+					overview: existingShow.overview ?? refreshed.overview,
+					genres: existingShow.genres ?? refreshed.genres,
+					rating: existingShow.rating ?? refreshed.rating,
+					posterUrl: existingShow.posterUrl ?? refreshed.posterUrl,
+					backdropUrl: existingShow.backdropUrl ?? refreshed.backdropUrl,
+					updatedAt: /* @__PURE__ */ new Date()
+				}).where(eq(shows.id, showId));
+			}
 		} else {
-			console.log(`  Fetching TMDB metadata for show: ${name}`);
+			console.log(`  Fetching metadata for show: ${name}`);
 			const metadata = await fetchShowMetadata(name, year ?? void 0);
 			const now = /* @__PURE__ */ new Date();
 			const newShow = {
 				title: metadata?.title ?? name,
 				folderPath,
-				tmdbId: metadata?.tmdbId ?? null,
+				externalId: metadata?.externalId ?? null,
 				year: metadata?.year ?? year ?? null,
 				overview: metadata?.overview ?? null,
 				genres: metadata?.genres ?? null,
 				rating: metadata?.rating ?? null,
-				posterPath: metadata?.posterPath ?? null,
-				backdropPath: metadata?.backdropPath ?? null,
+				posterUrl: metadata?.posterUrl ?? null,
+				backdropUrl: metadata?.backdropUrl ?? null,
 				createdAt: now,
 				updatedAt: now
 			};
 			showId = (await db.insert(shows).values(newShow).returning({ id: shows.id }))[0]?.id ?? 0;
-			tmdbId = metadata?.tmdbId ?? null;
+			externalId = metadata?.externalId ?? null;
 		}
 		const seasonMap = /* @__PURE__ */ new Map();
 		for (const episode of episodes$1) {
@@ -9267,33 +9259,33 @@ async function scanShowLibrary(libraryPath, onProgress) {
 			seasonMap.set(episode.seasonNumber, seasonEpisodes);
 		}
 		for (const [seasonNumber, seasonEpisodes] of seasonMap) {
-			let tmdbEpisodes = [];
+			let metadataEpisodes = [];
 			const existingSeasons = await db.select().from(seasons).where(and(eq(seasons.showId, showId), eq(seasons.seasonNumber, seasonNumber))).limit(1);
 			let seasonId;
 			if (existingSeasons.length > 0 && existingSeasons[0]) {
 				seasonId = existingSeasons[0].id;
-				if (tmdbId !== null) tmdbEpisodes = (await fetchSeasonMetadata(tmdbId, seasonNumber))?.episodes ?? [];
+				if (externalId !== null) metadataEpisodes = (await fetchSeasonMetadata(externalId, seasonNumber))?.episodes ?? [];
 			} else {
 				let seasonMetadata = null;
-				if (tmdbId !== null) {
-					console.log(`  Fetching TMDB metadata for season ${seasonNumber} of: ${name}`);
-					seasonMetadata = await fetchSeasonMetadata(tmdbId, seasonNumber);
-					tmdbEpisodes = seasonMetadata?.episodes ?? [];
+				if (externalId !== null) {
+					console.log(`  Fetching metadata for season ${seasonNumber} of: ${name}`);
+					seasonMetadata = await fetchSeasonMetadata(externalId, seasonNumber);
+					metadataEpisodes = seasonMetadata?.episodes ?? [];
 				}
 				const newSeason = {
 					showId,
 					seasonNumber,
 					name: seasonMetadata?.name ?? null,
 					overview: seasonMetadata?.overview ?? null,
-					posterPath: seasonMetadata?.posterPath ?? null,
+					posterUrl: seasonMetadata?.posterUrl ?? null,
 					episodeCount: seasonEpisodes.length
 				};
 				seasonId = (await db.insert(seasons).values(newSeason).returning({ id: seasons.id }))[0]?.id ?? 0;
 			}
 			for (const scannedEpisode of seasonEpisodes) {
 				total++;
-				const tmdbEpisode = tmdbEpisodes.find((e) => e.episodeNumber === scannedEpisode.episodeNumber);
-				const episodeTitle = tmdbEpisode?.title ?? scannedEpisode.title ?? `Episode ${scannedEpisode.episodeNumber}`;
+				const metadataEpisode = metadataEpisodes.find((e) => e.episodeNumber === scannedEpisode.episodeNumber);
+				const episodeTitle = metadataEpisode?.title ?? scannedEpisode.title ?? `Episode ${scannedEpisode.episodeNumber}`;
 				const existingEpisodes = await db.select().from(episodes).where(eq(episodes.filePath, scannedEpisode.filePath)).limit(1);
 				const now = /* @__PURE__ */ new Date();
 				let episodeId;
@@ -9323,10 +9315,10 @@ async function scanShowLibrary(libraryPath, onProgress) {
 						fileName: scannedEpisode.fileName,
 						fileSize: scannedEpisode.fileSize,
 						extension: scannedEpisode.extension,
-						tmdbId: tmdbEpisode ? null : null,
-						overview: tmdbEpisode?.overview ?? null,
-						runtime: tmdbEpisode?.runtime ?? null,
-						stillPath: tmdbEpisode?.stillPath ?? null,
+						externalId: null,
+						overview: metadataEpisode?.overview ?? null,
+						runtime: metadataEpisode?.runtime ?? null,
+						stillUrl: metadataEpisode?.stillUrl ?? null,
 						createdAt: now,
 						updatedAt: now
 					};
@@ -9728,18 +9720,18 @@ function searchMovies(matchExpression, limit) {
       movies.title AS title,
       movies.year AS year,
       movies.overview AS overview,
-      movies.poster_path AS poster_path,
-      movies.backdrop_path AS backdrop_path
+      movies.poster_url AS poster_url,
+      movies.backdrop_url AS backdrop_url
     FROM movies_fts
     JOIN movies ON movies.rowid = movies_fts.rowid
     WHERE movies_fts MATCH ${matchExpression}
     ORDER BY bm25(movies_fts) ASC
     LIMIT ${limit}
   `).map((row) => ({
-		backdropPath: row.backdrop_path,
+		backdropUrl: row.backdrop_url,
 		id: row.id,
 		overview: row.overview,
-		posterPath: row.poster_path,
+		posterUrl: row.poster_url,
 		title: row.title,
 		year: row.year
 	}));
@@ -9751,18 +9743,18 @@ function searchShows(matchExpression, limit) {
       shows.title AS title,
       shows.year AS year,
       shows.overview AS overview,
-      shows.poster_path AS poster_path,
-      shows.backdrop_path AS backdrop_path
+      shows.poster_url AS poster_url,
+      shows.backdrop_url AS backdrop_url
     FROM shows_fts
     JOIN shows ON shows.rowid = shows_fts.rowid
     WHERE shows_fts MATCH ${matchExpression}
     ORDER BY bm25(shows_fts) ASC
     LIMIT ${limit}
   `).map((row) => ({
-		backdropPath: row.backdrop_path,
+		backdropUrl: row.backdrop_url,
 		id: row.id,
 		overview: row.overview,
-		posterPath: row.poster_path,
+		posterUrl: row.poster_url,
 		title: row.title,
 		year: row.year
 	}));
@@ -9776,7 +9768,7 @@ function searchEpisodes(matchExpression, limit) {
       episodes.episode_number AS episode_number,
       episodes.title AS title,
       episodes.overview AS overview,
-      episodes.still_path AS still_path,
+      episodes.still_url AS still_url,
       shows.title AS show_title
     FROM episodes_fts
     JOIN episodes ON episodes.rowid = episodes_fts.rowid
@@ -9791,11 +9783,53 @@ function searchEpisodes(matchExpression, limit) {
 		seasonNumber: row.season_number,
 		showId: row.show_id,
 		showTitle: row.show_title ?? "",
-		stillPath: row.still_path,
+		stillUrl: row.still_url,
 		title: row.title
 	}));
 }
 //#endregion
+//#region src/services/settings.ts
+const scanScheduleSettingKey = "scanSchedule";
+const scanScheduleValues = [
+	"off",
+	"6h",
+	"12h",
+	"24h"
+];
+function isScanScheduleValue(value) {
+	return scanScheduleValues.includes(value);
+}
+/**
+* Read a setting value from the DB. Returns null when the key is not set.
+*
+* Accepts an optional database instance so tests and scripts can pass an
+* in-memory SQLite instance instead of the singleton.
+*/
+async function getSetting(key, database = db) {
+	const [row] = await database.select().from(settings).where(eq(settings.key, key)).limit(1);
+	return row?.value ?? null;
+}
+/**
+* Upsert a setting value.
+*
+* Uses a single INSERT ... ON CONFLICT so two concurrent callers don't both
+* read null, both INSERT, and fail with a UNIQUE constraint on the second.
+*/
+async function setSetting(key, value, database = db) {
+	const now = Date.now();
+	await database.insert(settings).values({
+		key,
+		value,
+		updatedAt: now
+	}).onConflictDoUpdate({
+		target: settings.key,
+		set: {
+			value,
+			updatedAt: now
+		}
+	});
+}
+//#endregion
 //#region src/services/scheduler.ts
 const millisecondsPerHour = 3600 * 1e3;
 function scheduleIntervalMilliseconds(value) {
@@ -9887,19 +9921,8 @@ function createScheduler(dependencies = {}) {
 const scheduler = createScheduler();
 //#endregion
 //#region src/api/routes/settings.ts
-const tmdbConfigurationUrl = "https://api.themoviedb.org/3/configuration";
-const reservedKeys = new Set([tmdbApiKeySettingKey, scanScheduleSettingKey]);
-const reservedKeyRoute = {
-	[tmdbApiKeySettingKey]: "/api/settings/tmdb-key",
-	[scanScheduleSettingKey]: "/api/settings/scan-schedule"
-};
-async function verifyTmdbKey(apiKey) {
-	try {
-		return (await fetch(`${tmdbConfigurationUrl}?api_key=${encodeURIComponent(apiKey)}`)).ok;
-	} catch {
-		return false;
-	}
-}
+const reservedKeys = new Set([scanScheduleSettingKey]);
+const reservedKeyRoute = { [scanScheduleSettingKey]: "/api/settings/scan-schedule" };
 async function pathIsReadable(path) {
 	try {
 		await access(path, constants.R_OK);
@@ -9932,26 +9955,6 @@ function libraryPathPrefixPattern(libraryPath) {
 	return `${(resolved.endsWith(path.sep) ? resolved : `${resolved}${path.sep}`).replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_")}%`;
 }
 const settingsRoutes = new Hono();
-settingsRoutes.get("/tmdb-key", async (context) => {
-	const apiKey = await getTmdbApiKey();
-	return context.json({
-		configured: apiKey !== null && apiKey.length > 0,
-		apiKey: apiKey ?? ""
-	});
-});
-settingsRoutes.put("/tmdb-key", async (context) => {
-	let body;
-	try {
-		body = await context.req.json();
-	} catch {
-		return context.json({ error: { message: "Invalid request body." } }, 400);
-	}
-	const apiKey = typeof body.apiKey === "string" ? body.apiKey.trim() : "";
-	if (apiKey.length === 0) return context.json({ error: { message: "TMDB API key is required. Get one at themoviedb.org/settings/api." } }, 400);
-	if (!await verifyTmdbKey(apiKey)) return context.json({ error: { message: "Couldn't save TMDB key — the key wasn't accepted by TMDB. Check it at themoviedb.org/settings/api." } }, 400);
-	await setTmdbApiKey(apiKey);
-	return context.json({ configured: true });
-});
 settingsRoutes.get("/libraries", async (context) => {
 	const libraries$2 = await db.select().from(libraries);
 	return context.json(libraries$2.map((library) => ({
@@ -10088,11 +10091,8 @@ settingsRoutes.put("/:key", async (context) => {
 //#region src/api/routes/setup.ts
 const setupRoutes = new Hono();
 setupRoutes.get("/", async (context) => {
-	const apiKey = await getTmdbApiKey();
 	const libraries$1 = await db.select().from(libraries);
 	return context.json({
-		config: apiKey !== null ? { tmdbApiKey: apiKey } : null,
-		hasApiKey: apiKey !== null && apiKey !== "",
 		libraries: libraries$1.map((library) => ({
 			id: library.id,
 			name: library.name,
@@ -10105,9 +10105,7 @@ setupRoutes.get("/", async (context) => {
 });
 setupRoutes.post("/complete", async (context) => {
 	const body = await context.req.json();
-	if (!body.tmdbApiKey) return context.json({ error: { message: "TMDB API key is required" } }, 400);
 	if (!body.libraries || body.libraries.length === 0) return context.json({ error: { message: "At least one library is required" } }, 400);
-	await setTmdbApiKey(body.tmdbApiKey);
 	await db.delete(libraries);
 	const now = /* @__PURE__ */ new Date();
 	for (const library of body.libraries) await db.insert(libraries).values({
@@ -10717,6 +10715,7 @@ app.route("/api/scan", scanRoutes);
 app.route("/api/search", searchRoutes);
 app.route("/api/profiles", profileRoutes);
 app.route("/api/favorites", favoriteRoutes);
+app.route("/api/filesystem", filesystemRoutes);
 app.route("/api/settings", settingsRoutes);
 app.route("/api/setup", setupRoutes);
 app.route("/api/stream/episode", episodeStreamRoutes);