feat: allow storing env variable in DB (#1802)

* feat(config): wip, make config controllable from DB, public side for now

* fix: build

* feat(config): add config manager env var toggle

* wip: make backend config use config manager

* fix: typechecks

* fix: circular import

* refactor: init hook sveltekit

* fix: disable config manager during tests

* refactor: use enum for semaphore, move delete from auto after 60s to separate `deleteAt` field

* feat: config manager checks for updates on requests

* fix: config script exit

* fix: remove top-level awaits

* fix: script await

* feat: filter config keys based on public environment variables for more security

* fix: change import to type for public environment variables

.env

@@ -1,11 +1,17 @@
 # Use .env.local to change these variables
 # DO NOT EDIT THIS FILE WITH SENSITIVE DATA
 
+### Config ###
+ENABLE_CONFIG_MANAGER=true
+
 ### MongoDB ###
 MONGODB_URL=#your mongodb URL here, use chat-ui-db image if you don't want to set this
 MONGODB_DB_NAME=chat-ui
 MONGODB_DIRECT_CONNECTION=false
 
+### Local Storage ###
+MODELS_STORAGE_PATH= # where are .gguf for model inference stored
+MONGO_STORAGE_PATH= # where is the db folder stored
 
 ### Endpoints config ###
 HF_API_ROOT=https://api-inference.huggingface.co/models
@@ -85,7 +91,7 @@ COOKIE_NAME=hf-chat
 # specify secure behaviour for cookies 
 COOKIE_SAMESITE=# can be "lax", "strict", "none" or left empty
 COOKIE_SECURE=# set to true to only allow cookies over https
-
+TRUSTED_EMAIL_HEADER=# header to use to get the user email, only use if you know what you are doing
 
 ### Admin stuff ###
 ADMIN_CLI_LOGIN=true # set to false to disable the CLI login
@@ -170,7 +176,7 @@ USE_HF_TOKEN_IN_API=false
 HF_ORG_ADMIN=
 HF_ORG_EARLY_ACCESS=
 WEBHOOK_URL_REPORT_ASSISTANT=#provide slack webhook url to get notified for reports/feature requests
-
+IP_TOKEN_SECRET=
 
 
 ### Metrics ###
@@ -208,3 +214,4 @@ OPENID_NAME_CLAIM="name" # Change to "username" for some providers that do not p
 OPENID_PROVIDER_URL=https://huggingface.co # for Google, use https://accounts.google.com
 OPENID_TOLERANCE=
 OPENID_RESOURCE=
+EXPOSE_API=# deprecated, API is now always exposed

chart/env/prod.yaml

@@ -39,6 +39,7 @@ envVars:
   COOKIE_SECURE: "true"
   ENABLE_ASSISTANTS: "true"
   ENABLE_ASSISTANTS_RAG: "true"
+  ENABLE_CONFIG_MANAGER: "false"
   METRICS_PORT: 5565
   LOG_LEVEL: "debug"
   METRICS_ENABLED: "true"

package.json

@@ -14,6 +14,7 @@
 		"test": "vitest",
 		"updateLocalEnv": "vite-node --options.transformMode.ssr='/.*/' scripts/updateLocalEnv.ts",
 		"populate": "vite-node --options.transformMode.ssr='/.*/' scripts/populate.ts",
+		"config": "vite-node --options.transformMode.ssr='/.*/' scripts/config.ts",
 		"prepare": "husky"
 	},
 	"devDependencies": {

scripts/config.ts

@@ -0,0 +1,64 @@
+import sade from "sade";
+
+// @ts-expect-error: vite-node makes the var available but the typescript compiler doesn't see them
+import { config, ready } from "$lib/server/config";
+
+const prog = sade("config");
+await ready;
+prog
+	.command("clear")
+	.describe("Clear all config keys")
+	.action(async () => {
+		console.log("Clearing config...");
+		await clear();
+	});
+
+prog
+	.command("add <key> <value>")
+	.describe("Add a new config key")
+	.action(async (key: string, value: string) => {
+		await add(key, value);
+	});
+
+prog
+	.command("remove <key>")
+	.describe("Remove a config key")
+	.action(async (key: string) => {
+		console.log(`Removing ${key}`);
+		await remove(key);
+		process.exit(0);
+	});
+
+prog
+	.command("help")
+	.describe("Show help information")
+	.action(() => {
+		prog.help();
+		process.exit(0);
+	});
+
+async function clear() {
+	await config.clear();
+	process.exit(0);
+}
+
+async function add(key: string, value: string) {
+	if (!key || !value) {
+		console.error("Key and value are required");
+		process.exit(1);
+	}
+	await config.set(key as keyof typeof config.keysFromEnv, value);
+	process.exit(0);
+}
+
+async function remove(key: string) {
+	if (!key) {
+		console.error("Key is required");
+		process.exit(1);
+	}
+	await config.delete(key as keyof typeof config.keysFromEnv);
+	process.exit(0);
+}
+
+// Parse arguments and handle help automatically
+prog.parse(process.argv);

src/hooks.server.ts

@@ -1,6 +1,5 @@
-import { env } from "$env/dynamic/private";
-import { env as envPublic } from "$env/dynamic/public";
-import type { Handle, HandleServerError } from "@sveltejs/kit";
+import { config, ready } from "$lib/server/config";
+import type { Handle, HandleServerError, ServerInit } from "@sveltejs/kit";
 import { collections } from "$lib/server/database";
 import { base } from "$app/paths";
 import { findUser, refreshSessionCookie, requiresUser } from "$lib/server/auth";
@@ -18,34 +17,39 @@ import { refreshAssistantsCounts } from "$lib/jobs/refresh-assistants-counts";
 import { refreshConversationStats } from "$lib/jobs/refresh-conversation-stats";
 import { adminTokenManager } from "$lib/server/adminToken";
 
-// TODO: move this code on a started server hook, instead of using a "building" flag
-if (!building) {
-	// Set HF_TOKEN as a process variable for Transformers.JS to see it
-	process.env.HF_TOKEN ??= env.HF_TOKEN;
+export const init: ServerInit = async () => {
+	// Wait for config to be fully loaded
+	await ready;
 
-	logger.info("Starting server...");
-	initExitHandler();
+	// TODO: move this code on a started server hook, instead of using a "building" flag
+	if (!building) {
+		// Set HF_TOKEN as a process variable for Transformers.JS to see it
+		process.env.HF_TOKEN ??= config.HF_TOKEN;
 
-	checkAndRunMigrations();
-	if (env.ENABLE_ASSISTANTS) {
-		refreshAssistantsCounts();
-	}
-	refreshConversationStats();
+		logger.info("Starting server...");
+		initExitHandler();
 
-	// Init metrics server
-	MetricsServer.getInstance();
+		checkAndRunMigrations();
+		if (config.ENABLE_ASSISTANTS) {
+			refreshAssistantsCounts();
+		}
+		refreshConversationStats();
 
-	// Init AbortedGenerations refresh process
-	AbortedGenerations.getInstance();
+		// Init metrics server
+		MetricsServer.getInstance();
 
-	adminTokenManager.displayToken();
+		// Init AbortedGenerations refresh process
+		AbortedGenerations.getInstance();
 
-	if (env.EXPOSE_API) {
-		logger.warn(
-			"The EXPOSE_API flag has been deprecated. The API is now required for chat-ui to work."
-		);
+		adminTokenManager.displayToken();
+
+		if (config.EXPOSE_API) {
+			logger.warn(
+				"The EXPOSE_API flag has been deprecated. The API is now required for chat-ui to work."
+			);
+		}
 	}
-}
+};
 
 export const handleError: HandleServerError = async ({ error, event, status, message }) => {
 	// handle 404
@@ -81,6 +85,10 @@ export const handleError: HandleServerError = async ({ error, event, status, mes
 };
 
 export const handle: Handle = async ({ event, resolve }) => {
+	await ready.then(() => {
+		config.checkForUpdates();
+	});
+
 	logger.debug({
 		locals: event.locals,
 		url: event.url.pathname,
@@ -101,7 +109,7 @@ export const handle: Handle = async ({ event, resolve }) => {
 	}
 
 	if (event.url.pathname.startsWith(`${base}/admin/`) || event.url.pathname === `${base}/admin`) {
-		const ADMIN_SECRET = env.ADMIN_API_SECRET || env.PARQUET_EXPORT_SECRET;
+		const ADMIN_SECRET = config.ADMIN_API_SECRET || config.PARQUET_EXPORT_SECRET;
 
 		if (!ADMIN_SECRET) {
 			return errorResponse(500, "Admin API is not configured");
@@ -112,11 +120,11 @@ export const handle: Handle = async ({ event, resolve }) => {
 		}
 	}
 
-	const token = event.cookies.get(env.COOKIE_NAME);
+	const token = event.cookies.get(config.COOKIE_NAME);
 
 	// if the trusted email header is set we use it to get the user email
-	const email = env.TRUSTED_EMAIL_HEADER
-		? event.request.headers.get(env.TRUSTED_EMAIL_HEADER)
+	const email = config.TRUSTED_EMAIL_HEADER
+		? event.request.headers.get(config.TRUSTED_EMAIL_HEADER)
 		: null;
 
 	let secretSessionId: string | null = null;
@@ -145,7 +153,10 @@ export const handle: Handle = async ({ event, resolve }) => {
 		if (user) {
 			event.locals.user = user;
 		}
-	} else if (event.url.pathname.startsWith(`${base}/api/`) && env.USE_HF_TOKEN_IN_API === "true") {
+	} else if (
+		event.url.pathname.startsWith(`${base}/api/`) &&
+		config.USE_HF_TOKEN_IN_API === "true"
+	) {
 		// if the request goes to the API and no user is available in the header
 		// check if a bearer token is available in the Authorization header
 
@@ -234,7 +245,7 @@ export const handle: Handle = async ({ event, resolve }) => {
 
 			const validOrigins = [
 				new URL(event.request.url).host,
-				...(envPublic.PUBLIC_ORIGIN ? [new URL(envPublic.PUBLIC_ORIGIN).host] : []),
+				...(config.PUBLIC_ORIGIN ? [new URL(config.PUBLIC_ORIGIN).host] : []),
 			];
 
 			if (!validOrigins.includes(new URL(origin).host)) {
@@ -262,7 +273,7 @@ export const handle: Handle = async ({ event, resolve }) => {
 		if (
 			!event.locals.user &&
 			requiresUser &&
-			!((env.MESSAGES_BEFORE_LOGIN ? parseInt(env.MESSAGES_BEFORE_LOGIN) : 0) > 0)
+			!((config.MESSAGES_BEFORE_LOGIN ? parseInt(config.MESSAGES_BEFORE_LOGIN) : 0) > 0)
 		) {
 			return errorResponse(401, ERROR_MESSAGES.authOnly);
 		}
@@ -273,7 +284,7 @@ export const handle: Handle = async ({ event, resolve }) => {
 		if (
 			!requiresUser &&
 			!event.url.pathname.startsWith(`${base}/settings`) &&
-			envPublic.PUBLIC_APP_DISCLAIMER === "1"
+			config.PUBLIC_APP_DISCLAIMER === "1"
 		) {
 			const hasAcceptedEthicsModal = await collections.settings.countDocuments({
 				sessionId: event.locals.sessionId,
@@ -296,12 +307,12 @@ export const handle: Handle = async ({ event, resolve }) => {
 			}
 			replaced = true;
 
-			return chunk.html.replace("%gaId%", envPublic.PUBLIC_GOOGLE_ANALYTICS_ID);
+			return chunk.html.replace("%gaId%", config.PUBLIC_GOOGLE_ANALYTICS_ID);
 		},
 	});
 
 	// Add CSP header to disallow framing if ALLOW_IFRAME is not "true"
-	if (env.ALLOW_IFRAME !== "true") {
+	if (config.ALLOW_IFRAME !== "true") {
 		response.headers.append("Content-Security-Policy", "frame-ancestors 'none';");
 	}
 

src/lib/components/AssistantSettings.svelte

@@ -12,7 +12,7 @@
 	import CarbonTools from "~icons/carbon/tools";
 
 	import { useSettingsStore } from "$lib/stores/settings";
-	import { isHuggingChat } from "$lib/utils/isHuggingChat";
+	import { publicConfig } from "$lib/utils/PublicConfig.svelte";
 	import IconInternet from "./icons/IconInternet.svelte";
 	import TokensCounter from "./TokensCounter.svelte";
 	import HoverTooltip from "./HoverTooltip.svelte";
@@ -457,7 +457,7 @@
 						>Internet access
 						<IconInternet classNames="inline text-sm text-blue-600" />
 
-						{#if isHuggingChat}
+						{#if publicConfig.isHuggingChat}
 							<a
 								href="https://huggingface.co/spaces/huggingchat/chat-ui/discussions/385"
 								target="_blank"

src/lib/components/DisclaimerModal.svelte

@@ -1,7 +1,8 @@
 <script lang="ts">
 	import { base } from "$app/paths";
 	import { page } from "$app/state";
-	import { env as envPublic } from "$env/dynamic/public";
+	import { publicConfig } from "$lib/utils/PublicConfig.svelte";
+
 	import LogoHuggingFaceBorderless from "$lib/components/icons/LogoHuggingFaceBorderless.svelte";
 	import Modal from "$lib/components/Modal.svelte";
 	import { useSettingsStore } from "$lib/stores/settings";
@@ -17,15 +18,15 @@
 	>
 		<h2 class="flex items-center text-2xl font-semibold text-gray-800">
 			<Logo classNames="mr-1" />
-			{envPublic.PUBLIC_APP_NAME}
+			{publicConfig.PUBLIC_APP_NAME}
 		</h2>
 
 		<p class="text-lg font-semibold leading-snug text-gray-800" style="text-wrap: balance;">
-			{envPublic.PUBLIC_APP_DESCRIPTION}
+			{publicConfig.PUBLIC_APP_DESCRIPTION}
 		</p>
 
 		<p class="text-sm text-gray-500">
-			{envPublic.PUBLIC_APP_DISCLAIMER_MESSAGE}
+			{publicConfig.PUBLIC_APP_DISCLAIMER_MESSAGE}
 		</p>
 
 		<div class="flex w-full flex-col items-center gap-2">
@@ -61,7 +62,7 @@
 						class="flex w-full flex-wrap items-center justify-center whitespace-nowrap rounded-full border-2 border-black bg-black px-5 py-2 text-lg font-semibold text-gray-100 transition-colors hover:bg-gray-900"
 					>
 						Sign in
-						{#if envPublic.PUBLIC_APP_NAME === "HuggingChat"}
+						{#if publicConfig.PUBLIC_APP_NAME === "HuggingChat"}
 							<span class="flex items-center">
 								&nbsp;with <LogoHuggingFaceBorderless classNames="text-xl mr-1 ml-1.5 flex-none" /> Hugging
 								Face

src/lib/components/LoginModal.svelte

@@ -1,7 +1,8 @@
 <script lang="ts">
 	import { base } from "$app/paths";
 	import { page } from "$app/state";
-	import { env as envPublic } from "$env/dynamic/public";
+	import { publicConfig } from "$lib/utils/PublicConfig.svelte";
+
 	import LogoHuggingFaceBorderless from "$lib/components/icons/LogoHuggingFaceBorderless.svelte";
 	import Modal from "$lib/components/Modal.svelte";
 	import { useSettingsStore } from "$lib/stores/settings";
@@ -17,13 +18,13 @@
 	>
 		<h2 class="flex items-center text-2xl font-semibold text-gray-800">
 			<Logo classNames="mr-1" />
-			{envPublic.PUBLIC_APP_NAME}
+			{publicConfig.PUBLIC_APP_NAME}
 		</h2>
 		<p class="text-balance text-lg font-semibold leading-snug text-gray-800">
-			{envPublic.PUBLIC_APP_DESCRIPTION}
+			{publicConfig.PUBLIC_APP_DESCRIPTION}
 		</p>
 		<p class="text-balance rounded-xl border bg-white/80 p-2 text-base text-gray-800">
-			{envPublic.PUBLIC_APP_GUEST_MESSAGE}
+			{publicConfig.PUBLIC_APP_GUEST_MESSAGE}
 		</p>
 
 		<form
@@ -38,7 +39,7 @@
 					class="flex w-full flex-wrap items-center justify-center whitespace-nowrap rounded-full bg-black px-5 py-2 text-center text-lg font-semibold text-gray-100 transition-colors hover:bg-gray-900"
 				>
 					Sign in
-					{#if envPublic.PUBLIC_APP_NAME === "HuggingChat"}
+					{#if publicConfig.PUBLIC_APP_NAME === "HuggingChat"}
 						<span class="flex items-center">
 							&nbsp;with <LogoHuggingFaceBorderless classNames="text-xl mr-1 ml-1.5" /> Hugging Face
 						</span>

src/lib/components/NavMenu.svelte

@@ -4,7 +4,8 @@
 	import Logo from "$lib/components/icons/Logo.svelte";
 	import { switchTheme } from "$lib/switchTheme";
 	import { isAborted } from "$lib/stores/isAborted";
-	import { env as envPublic } from "$env/dynamic/public";
+	import { publicConfig } from "$lib/utils/PublicConfig.svelte";
+
 	import NavConversationItem from "./NavConversationItem.svelte";
 	import type { LayoutData } from "../../routes/$types";
 	import type { ConvSidebar } from "$lib/types/ConvSidebar";
@@ -90,10 +91,10 @@
 >
 	<a
 		class="flex items-center rounded-xl text-lg font-semibold"
-		href="{envPublic.PUBLIC_ORIGIN}{base}/"
+		href="{publicConfig.PUBLIC_ORIGIN}{base}/"
 	>
 		<Logo classNames="mr-1" />
-		{envPublic.PUBLIC_APP_NAME}
+		{publicConfig.PUBLIC_APP_NAME}
 	</a>
 	{#if $page.url.pathname !== base + "/"}
 		<a
@@ -216,7 +217,7 @@
 	>
 		Settings
 	</a>
-	{#if envPublic.PUBLIC_APP_NAME === "HuggingChat"}
+	{#if publicConfig.PUBLIC_APP_NAME === "HuggingChat"}
 		<a
 			href="{base}/privacy"
 			class="flex h-9 flex-none items-center gap-1.5 rounded-lg pl-2.5 pr-2 text-gray-500 hover:bg-gray-100 dark:text-gray-400 dark:hover:bg-gray-700"

src/lib/components/ToolsMenu.svelte

@@ -4,7 +4,7 @@
 	import { clickOutside } from "$lib/actions/clickOutside";
 	import { useSettingsStore } from "$lib/stores/settings";
 	import type { ToolFront } from "$lib/types/Tool";
-	import { isHuggingChat } from "$lib/utils/isHuggingChat";
+	import { publicConfig } from "$lib/utils/PublicConfig.svelte";
 	import IconTool from "./icons/IconTool.svelte";
 	import CarbonInformation from "~icons/carbon/information";
 	import CarbonGlobe from "~icons/carbon/earth-filled";
@@ -71,7 +71,7 @@
 		<div class="grid grid-cols-2 gap-x-6 gap-y-1 p-3">
 			<div class="col-span-2 flex items-center gap-1.5 text-sm text-gray-500">
 				Available tools
-				{#if isHuggingChat}
+				{#if publicConfig.isHuggingChat}
 					<a
 						href="https://huggingface.co/spaces/huggingchat/chat-ui/discussions/470"
 						target="_blank"

src/lib/components/chat/AssistantIntroduction.svelte

@@ -15,7 +15,8 @@
 	import CarbonTools from "~icons/carbon/tools";
 
 	import { share } from "$lib/utils/share";
-	import { env as envPublic } from "$env/dynamic/public";
+	import { publicConfig } from "$lib/utils/PublicConfig.svelte";
+
 	import { page } from "$app/state";
 
 	interface Props {
@@ -48,7 +49,7 @@
 	);
 
 	const prefix =
-		envPublic.PUBLIC_SHARE_PREFIX || `${envPublic.PUBLIC_ORIGIN || page.url.origin}${base}`;
+		publicConfig.PUBLIC_SHARE_PREFIX || `${publicConfig.PUBLIC_ORIGIN || page.url.origin}${base}`;
 
 	let shareUrl = $derived(`${prefix}/assistant/${assistant?._id}`);
 

src/lib/components/chat/ChatIntroduction.svelte

@@ -1,5 +1,6 @@
 <script lang="ts">
-	import { env as envPublic } from "$env/dynamic/public";
+	import { publicConfig } from "$lib/utils/PublicConfig.svelte";
+
 	import Logo from "$lib/components/icons/Logo.svelte";
 	import { createEventDispatcher } from "svelte";
 	import IconGear from "~icons/bi/gear-fill";
@@ -15,10 +16,6 @@
 
 	let { currentModel }: Props = $props();
 
-	const announcementBanners = envPublic.PUBLIC_ANNOUNCEMENT_BANNERS
-		? JSON5.parse(envPublic.PUBLIC_ANNOUNCEMENT_BANNERS)
-		: [];
-
 	const dispatch = createEventDispatcher<{ message: string }>();
 </script>
 
@@ -27,21 +24,21 @@
 		<div>
 			<div class="mb-3 flex items-center text-2xl font-semibold">
 				<Logo classNames="mr-1 flex-none" />
-				{envPublic.PUBLIC_APP_NAME}
+				{publicConfig.PUBLIC_APP_NAME}
 				<div
 					class="ml-3 flex h-6 items-center rounded-lg border border-gray-100 bg-gray-50 px-2 text-base text-gray-400 dark:border-gray-700/60 dark:bg-gray-800"
 				>
-					v{envPublic.PUBLIC_VERSION}
+					v{publicConfig.PUBLIC_VERSION}
 				</div>
 			</div>
 			<p class="text-base text-gray-600 dark:text-gray-400">
-				{envPublic.PUBLIC_APP_DESCRIPTION ||
+				{publicConfig.PUBLIC_APP_DESCRIPTION ||
 					"Making the community's best AI chat models available to everyone."}
 			</p>
 		</div>
 	</div>
 	<div class="lg:col-span-2 lg:pl-24">
-		{#each announcementBanners as banner}
+		{#each JSON5.parse(publicConfig.PUBLIC_ANNOUNCEMENT_BANNERS || "[]") as banner}
 			<AnnouncementBanner classNames="mb-4" title={banner.title}>
 				<a
 					target={banner.external ? "_blank" : "_self"}

src/lib/components/icons/Logo.svelte

@@ -1,6 +1,7 @@
 <script lang="ts">
 	import { page } from "$app/state";
-	import { env as envPublic } from "$env/dynamic/public";
+	import { publicConfig } from "$lib/utils/PublicConfig.svelte";
+
 	import { base } from "$app/paths";
 
 	interface Props {
@@ -13,13 +14,14 @@
 <svelte:head>
 	<link
 		rel="preload"
-		href="{envPublic.PUBLIC_ORIGIN || page.url.origin}{base}/{envPublic.PUBLIC_APP_ASSETS}/logo.svg"
+		href="{publicConfig.PUBLIC_ORIGIN ||
+			page.url.origin}{base}/{publicConfig.PUBLIC_APP_ASSETS}/logo.svg"
 		as="image"
 		type="image/svg+xml"
 	/>
 </svelte:head>
 
-{#if envPublic.PUBLIC_APP_ASSETS === "chatui"}
+{#if publicConfig.PUBLIC_APP_ASSETS === "chatui"}
 	<svg
 		height="30"
 		width="30"
@@ -35,7 +37,8 @@
 {:else}
 	<img
 		class={classNames}
-		alt="{envPublic.PUBLIC_APP_NAME} logo"
-		src="{envPublic.PUBLIC_ORIGIN || page.url.origin}{base}/{envPublic.PUBLIC_APP_ASSETS}/logo.svg"
+		alt="{publicConfig.PUBLIC_APP_NAME} logo"
+		src="{publicConfig.PUBLIC_ORIGIN ||
+			page.url.origin}{base}/{publicConfig.PUBLIC_APP_ASSETS}/logo.svg"
 	/>
 {/if}

src/lib/jobs/refresh-assistants-counts.ts

@@ -4,8 +4,7 @@ import type { ObjectId } from "mongodb";
 import { subDays } from "date-fns";
 import { logger } from "$lib/server/logger";
 import { collections } from "$lib/server/database";
-const LOCK_KEY = "assistants.count";
-
+import { Semaphores } from "$lib/types/Semaphore";
 let hasLock = false;
 let lockId: ObjectId | null = null;
 
@@ -76,13 +75,13 @@ async function refreshAssistantsCountsHelper() {
 
 async function maintainLock() {
 	if (hasLock && lockId) {
-		hasLock = await refreshLock(LOCK_KEY, lockId);
+		hasLock = await refreshLock(Semaphores.ASSISTANTS_COUNT, lockId);
 
 		if (!hasLock) {
 			lockId = null;
 		}
 	} else if (!hasLock) {
-		lockId = (await acquireLock(LOCK_KEY)) || null;
+		lockId = (await acquireLock(Semaphores.ASSISTANTS_COUNT)) || null;
 		hasLock = !!lockId;
 	}
 

src/lib/jobs/refresh-conversation-stats.ts

@@ -3,6 +3,7 @@ import { CONVERSATION_STATS_COLLECTION, collections } from "$lib/server/database
 import { logger } from "$lib/server/logger";
 import type { ObjectId } from "mongodb";
 import { acquireLock, refreshLock } from "$lib/migrations/lock";
+import { Semaphores } from "$lib/types/Semaphore";
 
 async function getLastComputationTime(): Promise<Date> {
 	const lastStats = await collections.conversationStats.findOne({}, { sort: { "date.at": -1 } });
@@ -234,20 +235,18 @@ async function computeStats(params: {
 	);
 }
 
-const LOCK_KEY = "conversation.stats";
-
 let hasLock = false;
 let lockId: ObjectId | null = null;
 
 async function maintainLock() {
 	if (hasLock && lockId) {
-		hasLock = await refreshLock(LOCK_KEY, lockId);
+		hasLock = await refreshLock(Semaphores.CONVERSATION_STATS, lockId);
 
 		if (!hasLock) {
 			lockId = null;
 		}
 	} else if (!hasLock) {
-		lockId = (await acquireLock(LOCK_KEY)) || null;
+		lockId = (await acquireLock(Semaphores.CONVERSATION_STATS)) || null;
 		hasLock = !!lockId;
 	}
 

src/lib/migrations/lock.ts

@@ -1,10 +1,11 @@
 import { collections } from "$lib/server/database";
 import { ObjectId } from "mongodb";
+import type { Semaphores } from "$lib/types/Semaphore";
 
 /**
  * Returns the lock id if the lock was acquired, false otherwise
  */
-export async function acquireLock(key: string): Promise<ObjectId | false> {
+export async function acquireLock(key: Semaphores): Promise<ObjectId | false> {
 	try {
 		const id = new ObjectId();
 
@@ -13,6 +14,7 @@ export async function acquireLock(key: string): Promise<ObjectId | false> {
 			key,
 			createdAt: new Date(),
 			updatedAt: new Date(),
+			deleteAt: new Date(Date.now() + 1000 * 60 * 3), // 3 minutes
 		});
 
 		return insert.acknowledged ? id : false; // true if the document was inserted
@@ -22,21 +24,21 @@ export async function acquireLock(key: string): Promise<ObjectId | false> {
 	}
 }
 
-export async function releaseLock(key: string, lockId: ObjectId) {
+export async function releaseLock(key: Semaphores, lockId: ObjectId) {
 	await collections.semaphores.deleteOne({
 		_id: lockId,
 		key,
 	});
 }
 
-export async function isDBLocked(key: string): Promise<boolean> {
+export async function isDBLocked(key: Semaphores): Promise<boolean> {
 	const res = await collections.semaphores.countDocuments({
 		key,
 	});
 	return res > 0;
 }
 
-export async function refreshLock(key: string, lockId: ObjectId): Promise<boolean> {
+export async function refreshLock(key: Semaphores, lockId: ObjectId): Promise<boolean> {
 	const result = await collections.semaphores.updateOne(
 		{
 			_id: lockId,
@@ -45,6 +47,7 @@ export async function refreshLock(key: string, lockId: ObjectId): Promise<boolea
 		{
 			$set: {
 				updatedAt: new Date(),
+				deleteAt: new Date(Date.now() + 1000 * 60 * 3), // 3 minutes
 			},
 		}
 	);

src/lib/migrations/migrations.spec.ts

@@ -1,10 +1,9 @@
 import { afterEach, assert, describe, expect, it } from "vitest";
 import { migrations } from "./routines";
 import { acquireLock, isDBLocked, refreshLock, releaseLock } from "./lock";
+import { Semaphores } from "$lib/types/Semaphore";
 import { collections } from "$lib/server/database";
 
-const LOCK_KEY = "migrations.test";
-
 describe(
 	"migrations",
 	{
@@ -18,7 +17,9 @@ describe(
 		});
 
 		it("should acquire only one lock on DB", async () => {
-			const results = await Promise.all(new Array(1000).fill(0).map(() => acquireLock(LOCK_KEY)));
+			const results = await Promise.all(
+				new Array(1000).fill(0).map(() => acquireLock(Semaphores.TEST_MIGRATION))
+			);
 			const locks = results.filter((r) => r);
 
 			const semaphores = await collections.semaphores.find({}).toArray();
@@ -26,20 +27,20 @@ describe(
 			expect(locks.length).toBe(1);
 			expect(semaphores).toBeDefined();
 			expect(semaphores.length).toBe(1);
-			expect(semaphores?.[0].key).toBe(LOCK_KEY);
+			expect(semaphores?.[0].key).toBe(Semaphores.TEST_MIGRATION);
 		});
 
 		it("should read the lock correctly", async () => {
-			const lockId = await acquireLock(LOCK_KEY);
+			const lockId = await acquireLock(Semaphores.TEST_MIGRATION);
 			assert(lockId);
-			expect(await isDBLocked(LOCK_KEY)).toBe(true);
-			expect(!!(await acquireLock(LOCK_KEY))).toBe(false);
-			await releaseLock(LOCK_KEY, lockId);
-			expect(await isDBLocked(LOCK_KEY)).toBe(false);
+			expect(await isDBLocked(Semaphores.TEST_MIGRATION)).toBe(true);
+			expect(!!(await acquireLock(Semaphores.TEST_MIGRATION))).toBe(false);
+			await releaseLock(Semaphores.TEST_MIGRATION, lockId);
+			expect(await isDBLocked(Semaphores.TEST_MIGRATION)).toBe(false);
 		});
 
 		it("should refresh the lock", async () => {
-			const lockId = await acquireLock(LOCK_KEY);
+			const lockId = await acquireLock(Semaphores.TEST_MIGRATION);
 
 			assert(lockId);
 
@@ -47,7 +48,7 @@ describe(
 
 			const updatedAtInitially = (await collections.semaphores.findOne({}))?.updatedAt;
 
-			await refreshLock(LOCK_KEY, lockId);
+			await refreshLock(Semaphores.TEST_MIGRATION, lockId);
 
 			const updatedAtAfterRefresh = (await collections.semaphores.findOne({}))?.updatedAt;
 

src/lib/migrations/migrations.ts

@@ -1,10 +1,9 @@
 import { Database } from "$lib/server/database";
 import { migrations } from "./routines";
 import { acquireLock, releaseLock, isDBLocked, refreshLock } from "./lock";
-import { isHuggingChat } from "$lib/utils/isHuggingChat";
+import { Semaphores } from "$lib/types/Semaphore";
 import { logger } from "$lib/server/logger";
-
-const LOCK_KEY = "migrations";
+import { config } from "$lib/server/config";
 
 export async function checkAndRunMigrations() {
 	// make sure all GUIDs are unique
@@ -23,7 +22,7 @@ export async function checkAndRunMigrations() {
 	// connect to the database
 	const connectedClient = await (await Database.getInstance()).getClient().connect();
 
-	const lockId = await acquireLock(LOCK_KEY);
+	const lockId = await acquireLock(Semaphores.MIGRATION);
 
 	if (!lockId) {
 		// another instance already has the lock, so we exit early
@@ -33,7 +32,7 @@ export async function checkAndRunMigrations() {
 
 		// Todo: is this necessary? Can we just return?
 		// block until the lock is released
-		while (await isDBLocked(LOCK_KEY)) {
+		while (await isDBLocked(Semaphores.MIGRATION)) {
 			await new Promise((resolve) => setTimeout(resolve, 1000));
 		}
 		return;
@@ -42,7 +41,7 @@ export async function checkAndRunMigrations() {
 	// once here, we have the lock
 	// make sure to refresh it regularly while it's running
 	const refreshInterval = setInterval(async () => {
-		await refreshLock(LOCK_KEY, lockId);
+		await refreshLock(Semaphores.MIGRATION, lockId);
 	}, 1000 * 10);
 
 	// iterate over all migrations
@@ -58,8 +57,8 @@ export async function checkAndRunMigrations() {
 		} else {
 			// check the modifiers to see if some cases match
 			if (
-				(migration.runForHuggingChat === "only" && !isHuggingChat) ||
-				(migration.runForHuggingChat === "never" && isHuggingChat)
+				(migration.runForHuggingChat === "only" && !config.isHuggingChat) ||
+				(migration.runForHuggingChat === "never" && config.isHuggingChat)
 			) {
 				logger.debug(
 					`[MIGRATIONS] "${migration.name}" should not be applied for this run. Skipping...`
@@ -115,5 +114,5 @@ export async function checkAndRunMigrations() {
 	logger.debug("[MIGRATIONS] All migrations applied. Releasing lock");
 
 	clearInterval(refreshInterval);
-	await releaseLock(LOCK_KEY, lockId);
+	await releaseLock(Semaphores.MIGRATION, lockId);
 }

src/lib/server/adminToken.ts

@@ -1,17 +1,16 @@
-import { env } from "$env/dynamic/private";
-import { env as envPublic } from "$env/dynamic/public";
+import { config } from "$lib/server/config";
 import type { Session } from "$lib/types/Session";
 import { logger } from "./logger";
 import { v4 } from "uuid";
 
 class AdminTokenManager {
-	private token = env.ADMIN_TOKEN || v4();
+	private token = config.ADMIN_TOKEN || v4();
 	// contains all session ids that are currently admin sessions
 	private adminSessions: Array<Session["sessionId"]> = [];
 
 	public get enabled() {
 		// if open id is configured, disable the feature
-		return env.ADMIN_CLI_LOGIN === "true";
+		return config.ADMIN_CLI_LOGIN === "true";
 	}
 	public isAdmin(sessionId: Session["sessionId"]) {
 		if (!this.enabled) return false;
@@ -23,7 +22,7 @@ class AdminTokenManager {
 		if (token === this.token) {
 			logger.info(`[ADMIN] Token validated`);
 			this.adminSessions.push(sessionId);
-			this.token = env.ADMIN_TOKEN || v4();
+			this.token = config.ADMIN_TOKEN || v4();
 			return true;
 		}
 
@@ -36,7 +35,7 @@ class AdminTokenManager {
 
 	public displayToken() {
 		// if admin token is set, don't display it
-		if (!this.enabled || env.ADMIN_TOKEN) return;
+		if (!this.enabled || config.ADMIN_TOKEN) return;
 
 		let port = process.argv.includes("--port")
 			? parseInt(process.argv[process.argv.indexOf("--port") + 1])
@@ -53,7 +52,7 @@ class AdminTokenManager {
 			}
 		}
 
-		const url = (envPublic.PUBLIC_ORIGIN || `http://localhost:${port}`) + "?token=";
+		const url = (config.PUBLIC_ORIGIN || `http://localhost:${port}`) + "?token=";
 		logger.info(`[ADMIN] You can login with ${url + this.token}`);
 	}
 }

src/lib/server/auth.ts

@@ -6,7 +6,7 @@ import {
 	custom,
 } from "openid-client";
 import { addHours, addWeeks } from "date-fns";
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import { sha256 } from "$lib/utils/sha256";
 import { z } from "zod";
 import { dev } from "$app/environment";
@@ -32,34 +32,34 @@ const stringWithDefault = (value: string) =>
 
 export const OIDConfig = z
 	.object({
-		CLIENT_ID: stringWithDefault(env.OPENID_CLIENT_ID),
-		CLIENT_SECRET: stringWithDefault(env.OPENID_CLIENT_SECRET),
-		PROVIDER_URL: stringWithDefault(env.OPENID_PROVIDER_URL),
-		SCOPES: stringWithDefault(env.OPENID_SCOPES),
-		NAME_CLAIM: stringWithDefault(env.OPENID_NAME_CLAIM).refine(
+		CLIENT_ID: stringWithDefault(config.OPENID_CLIENT_ID),
+		CLIENT_SECRET: stringWithDefault(config.OPENID_CLIENT_SECRET),
+		PROVIDER_URL: stringWithDefault(config.OPENID_PROVIDER_URL),
+		SCOPES: stringWithDefault(config.OPENID_SCOPES),
+		NAME_CLAIM: stringWithDefault(config.OPENID_NAME_CLAIM).refine(
 			(el) => !["preferred_username", "email", "picture", "sub"].includes(el),
 			{ message: "nameClaim cannot be one of the restricted keys." }
 		),
-		TOLERANCE: stringWithDefault(env.OPENID_TOLERANCE),
-		RESOURCE: stringWithDefault(env.OPENID_RESOURCE),
+		TOLERANCE: stringWithDefault(config.OPENID_TOLERANCE),
+		RESOURCE: stringWithDefault(config.OPENID_RESOURCE),
 		ID_TOKEN_SIGNED_RESPONSE_ALG: z.string().optional(),
 	})
-	.parse(JSON5.parse(env.OPENID_CONFIG || "{}"));
+	.parse(JSON5.parse(config.OPENID_CONFIG || "{}"));
 
 export const requiresUser = !!OIDConfig.CLIENT_ID && !!OIDConfig.CLIENT_SECRET;
 
 const sameSite = z
 	.enum(["lax", "none", "strict"])
-	.default(dev || env.ALLOW_INSECURE_COOKIES === "true" ? "lax" : "none")
-	.parse(env.COOKIE_SAMESITE === "" ? undefined : env.COOKIE_SAMESITE);
+	.default(dev || config.ALLOW_INSECURE_COOKIES === "true" ? "lax" : "none")
+	.parse(config.COOKIE_SAMESITE === "" ? undefined : config.COOKIE_SAMESITE);
 
 const secure = z
 	.boolean()
-	.default(!(dev || env.ALLOW_INSECURE_COOKIES === "true"))
-	.parse(env.COOKIE_SECURE === "" ? undefined : env.COOKIE_SECURE === "true");
+	.default(!(dev || config.ALLOW_INSECURE_COOKIES === "true"))
+	.parse(config.COOKIE_SECURE === "" ? undefined : config.COOKIE_SECURE === "true");
 
 export function refreshSessionCookie(cookies: Cookies, sessionId: string) {
-	cookies.set(env.COOKIE_NAME, sessionId, {
+	cookies.set(config.COOKIE_NAME, sessionId, {
 		path: "/",
 		// So that it works inside the space's iframe
 		sameSite,

src/lib/server/config.ts

@@ -0,0 +1,182 @@
+import { env as publicEnv } from "$env/dynamic/public";
+import { env as serverEnv } from "$env/dynamic/private";
+import { publicConfig } from "$lib/utils/PublicConfig.svelte";
+import { building } from "$app/environment";
+import type { Collection } from "mongodb";
+import type { ConfigKey as ConfigKeyType } from "$lib/types/ConfigKey";
+import type { Semaphore } from "$lib/types/Semaphore";
+import { Semaphores } from "$lib/types/Semaphore";
+
+export type PublicConfigKey = keyof typeof publicEnv;
+const keysFromEnv = { ...publicEnv, ...serverEnv };
+export type ConfigKey = keyof typeof keysFromEnv;
+
+class ConfigManager {
+	private keysFromDB: Partial<Record<ConfigKey, string>> = {};
+	private isInitialized = false;
+
+	private configCollection: Collection<ConfigKeyType> | undefined;
+	private semaphoreCollection: Collection<Semaphore> | undefined;
+	private lastConfigUpdate: Date | undefined;
+
+	async init() {
+		if (this.isInitialized) return;
+
+		if (import.meta.env.MODE === "test") {
+			this.isInitialized = true;
+			return;
+		}
+
+		const { collections, ready } = await import("./database");
+		await ready;
+		if (!collections) {
+			throw new Error("Database not initialized");
+		}
+
+		this.configCollection = collections.config;
+		this.semaphoreCollection = collections.semaphores;
+
+		await this.checkForUpdates().then(() => {
+			this.isInitialized = true;
+		});
+	}
+
+	get ConfigManagerEnabled() {
+		return serverEnv.ENABLE_CONFIG_MANAGER === "true" && import.meta.env.MODE !== "test";
+	}
+
+	get isHuggingChat() {
+		return this.get("PUBLIC_APP_ASSETS") === "huggingchat";
+	}
+
+	async checkForUpdates() {
+		if (await this.isConfigStale()) {
+			await this.updateConfig();
+		}
+	}
+
+	async isConfigStale(): Promise<boolean> {
+		if (!this.lastConfigUpdate || !this.isInitialized) {
+			return true;
+		}
+		const count = await this.semaphoreCollection?.countDocuments({
+			key: Semaphores.CONFIG_UPDATE,
+			updatedAt: { $gt: this.lastConfigUpdate },
+		});
+		return count !== undefined && count > 0;
+	}
+
+	async updateConfig() {
+		const configs = (await this.configCollection?.find({}).toArray()) ?? [];
+		this.keysFromDB = configs.reduce(
+			(acc, curr) => {
+				acc[curr.key as ConfigKey] = curr.value;
+				return acc;
+			},
+			{} as Record<ConfigKey, string>
+		);
+
+		this.lastConfigUpdate = new Date();
+	}
+
+	get(key: ConfigKey): string {
+		if (!this.ConfigManagerEnabled) {
+			return keysFromEnv[key] || "";
+		}
+		return this.keysFromDB[key] || keysFromEnv[key] || "";
+	}
+
+	async updateSemaphore() {
+		await this.semaphoreCollection?.updateOne(
+			{ key: Semaphores.CONFIG_UPDATE },
+			{
+				$set: {
+					updatedAt: new Date(),
+				},
+				$setOnInsert: {
+					createdAt: new Date(),
+				},
+			},
+			{ upsert: true }
+		);
+	}
+
+	async set(key: ConfigKey, value: string) {
+		if (!this.ConfigManagerEnabled) throw new Error("Config manager is disabled");
+		await this.configCollection?.updateOne({ key }, { $set: { value } }, { upsert: true });
+		this.keysFromDB[key] = value;
+		await this.updateSemaphore();
+	}
+
+	async delete(key: ConfigKey) {
+		if (!this.ConfigManagerEnabled) throw new Error("Config manager is disabled");
+		await this.configCollection?.deleteOne({ key });
+		delete this.keysFromDB[key];
+		await this.updateSemaphore();
+	}
+
+	async clear() {
+		if (!this.ConfigManagerEnabled) throw new Error("Config manager is disabled");
+		await this.configCollection?.deleteMany({});
+		this.keysFromDB = {};
+		await this.updateSemaphore();
+	}
+
+	getPublicConfig() {
+		let config = {
+			...Object.fromEntries(
+				Object.entries(keysFromEnv).filter(([key]) => key.startsWith("PUBLIC_"))
+			),
+		} as Record<PublicConfigKey, string>;
+
+		if (this.ConfigManagerEnabled) {
+			config = {
+				...config,
+				...Object.fromEntries(
+					Object.entries(this.keysFromDB).filter(([key]) => key.startsWith("PUBLIC_"))
+				),
+			};
+		}
+
+		const publicEnvKeys = Object.keys(publicEnv);
+
+		return Object.fromEntries(
+			Object.entries(config).filter(([key]) => publicEnvKeys.includes(key))
+		) as Record<PublicConfigKey, string>;
+	}
+}
+
+// Create the instance and initialize it.
+const configManager = new ConfigManager();
+
+export const ready = (async () => {
+	if (!building) {
+		await configManager.init().then(() => {
+			publicConfig.init(configManager.getPublicConfig());
+		});
+	}
+})();
+
+type ConfigProxy = ConfigManager & { [K in ConfigKey]: string };
+
+export const config: ConfigProxy = new Proxy(configManager, {
+	get(target, prop, receiver) {
+		if (prop in target) {
+			return Reflect.get(target, prop, receiver);
+		}
+		if (typeof prop === "string") {
+			return target.get(prop as ConfigKey);
+		}
+		return undefined;
+	},
+	set(target, prop, value, receiver) {
+		if (prop in target) {
+			return Reflect.set(target, prop, value, receiver);
+		}
+		if (typeof prop === "string") {
+			target.set(prop as ConfigKey, value);
+			return true;
+		}
+		return false;
+	},
+}) as ConfigProxy;

src/lib/server/database.ts

@@ -1,4 +1,3 @@
-import { env } from "$env/dynamic/private";
 import { GridFSBucket, MongoClient } from "mongodb";
 import type { Conversation } from "$lib/types/Conversation";
 import type { SharedConversation } from "$lib/types/SharedConversation";
@@ -23,12 +22,11 @@ import { fileURLToPath } from "url";
 import { dirname, join } from "path";
 import { existsSync, mkdirSync } from "fs";
 import { findRepoRoot } from "./findRepoRoot";
+import type { ConfigKey } from "$lib/types/ConfigKey";
+import { config } from "$lib/server/config";
 
 export const CONVERSATION_STATS_COLLECTION = "conversations.stats";
 
-export const DB_FOLDER =
-	env.MONGO_STORAGE_PATH || join(findRepoRoot(dirname(fileURLToPath(import.meta.url))), "db");
-
 export class Database {
 	private client?: MongoClient;
 	private mongoServer?: MongoMemoryServer;
@@ -36,7 +34,11 @@ export class Database {
 	private static instance: Database;
 
 	private async init() {
-		if (!env.MONGODB_URL) {
+		const DB_FOLDER =
+			config.MONGO_STORAGE_PATH ||
+			join(findRepoRoot(dirname(fileURLToPath(import.meta.url))), "db");
+
+		if (!config.MONGODB_URL) {
 			logger.warn("No MongoDB URL found, using in-memory server");
 
 			logger.info(`Using database path: ${DB_FOLDER}`);
@@ -48,7 +50,7 @@ export class Database {
 
 			this.mongoServer = await MongoMemoryServer.create({
 				instance: {
-					dbName: env.MONGODB_DB_NAME + (import.meta.env.MODE === "test" ? "-test" : ""),
+					dbName: config.MONGODB_DB_NAME + (import.meta.env.MODE === "test" ? "-test" : ""),
 					dbPath: DB_FOLDER,
 				},
 				binary: {
@@ -56,11 +58,11 @@ export class Database {
 				},
 			});
 			this.client = new MongoClient(this.mongoServer.getUri(), {
-				directConnection: env.MONGODB_DIRECT_CONNECTION === "true",
+				directConnection: config.MONGODB_DIRECT_CONNECTION === "true",
 			});
 		} else {
-			this.client = new MongoClient(env.MONGODB_URL, {
-				directConnection: env.MONGODB_DIRECT_CONNECTION === "true",
+			this.client = new MongoClient(config.MONGODB_URL, {
+				directConnection: config.MONGODB_DIRECT_CONNECTION === "true",
 			});
 		}
 
@@ -68,7 +70,7 @@ export class Database {
 			logger.error(err, "Connection error");
 			process.exit(1);
 		});
-		this.client.db(env.MONGODB_DB_NAME + (import.meta.env.MODE === "test" ? "-test" : ""));
+		this.client.db(config.MONGODB_DB_NAME + (import.meta.env.MODE === "test" ? "-test" : ""));
 		this.client.on("open", () => this.initDatabase());
 
 		// Disconnect DB on exit
@@ -108,7 +110,7 @@ export class Database {
 		}
 
 		const db = this.client.db(
-			env.MONGODB_DB_NAME + (import.meta.env.MODE === "test" ? "-test" : "")
+			config.MONGODB_DB_NAME + (import.meta.env.MODE === "test" ? "-test" : "")
 		);
 
 		const conversations = db.collection<Conversation>("conversations");
@@ -127,6 +129,7 @@ export class Database {
 		const semaphores = db.collection<Semaphore>("semaphores");
 		const tokenCaches = db.collection<TokenCache>("tokens");
 		const tools = db.collection<CommunityToolDB>("tools");
+		const configCollection = db.collection<ConfigKey>("config");
 
 		return {
 			conversations,
@@ -145,6 +148,7 @@ export class Database {
 			semaphores,
 			tokenCaches,
 			tools,
+			config: configCollection,
 		};
 	}
 
@@ -168,6 +172,7 @@ export class Database {
 			semaphores,
 			tokenCaches,
 			tools,
+			config,
 		} = this.getCollections();
 
 		conversations
@@ -258,7 +263,7 @@ export class Database {
 		// Unique index for semaphore and migration results
 		semaphores.createIndex({ key: 1 }, { unique: true }).catch((e) => logger.error(e));
 		semaphores
-			.createIndex({ createdAt: 1 }, { expireAfterSeconds: 60 })
+			.createIndex({ deleteAt: 1 }, { expireAfterSeconds: 1 })
 			.catch((e) => logger.error(e));
 		tokenCaches
 			.createIndex({ createdAt: 1 }, { expireAfterSeconds: 5 * 60 })
@@ -281,9 +286,18 @@ export class Database {
 				sessionId: 1,
 			})
 			.catch((e) => logger.error(e));
+
+		config.createIndex({ key: 1 }, { unique: true }).catch((e) => logger.error(e));
 	}
 }
 
-export const collections = building
-	? ({} as unknown as ReturnType<typeof Database.prototype.getCollections>)
-	: await Database.getInstance().then((db) => db.getCollections());
+export let collections: ReturnType<typeof Database.prototype.getCollections>;
+
+export const ready = (async () => {
+	if (!building) {
+		await Database.getInstance();
+		collections = await Database.getInstance().then((db) => db.getCollections());
+	} else {
+		collections = {} as unknown as ReturnType<typeof Database.prototype.getCollections>;
+	}
+})();

src/lib/server/embeddingEndpoints/hfApi/embeddingHfApi.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import type { EmbeddingEndpoint, Embedding } from "../embeddingEndpoints";
 import { chunk } from "$lib/utils/chunk";
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import { logger } from "$lib/server/logger";
 
 export const embeddingEndpointHfApiSchema = z.object({
@@ -11,14 +11,14 @@ export const embeddingEndpointHfApiSchema = z.object({
 	authorization: z
 		.string()
 		.optional()
-		.transform((v) => (!v && env.HF_TOKEN ? "Bearer " + env.HF_TOKEN : v)), // if the header is not set but HF_TOKEN is, use it as the authorization header
+		.transform((v) => (!v && config.HF_TOKEN ? "Bearer " + config.HF_TOKEN : v)), // if the header is not set but HF_TOKEN is, use it as the authorization header
 });
 
 export async function embeddingEndpointHfApi(
 	input: z.input<typeof embeddingEndpointHfApiSchema>
 ): Promise<EmbeddingEndpoint> {
 	const { model, authorization } = embeddingEndpointHfApiSchema.parse(input);
-	const url = `${env.HF_API_ROOT}/${model.id}`;
+	const url = `${config.HF_API_ROOT}/${model.id}`;
 
 	return async ({ inputs }) => {
 		const batchesInputs = chunk(inputs, 128);

src/lib/server/embeddingEndpoints/openai/embeddingEndpoints.ts

@@ -1,14 +1,14 @@
 import { z } from "zod";
 import type { EmbeddingEndpoint, Embedding } from "../embeddingEndpoints";
 import { chunk } from "$lib/utils/chunk";
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 
 export const embeddingEndpointOpenAIParametersSchema = z.object({
 	weight: z.number().int().positive().default(1),
 	model: z.any(),
 	type: z.literal("openai"),
 	url: z.string().url().default("https://api.openai.com/v1/embeddings"),
-	apiKey: z.string().default(env.OPENAI_API_KEY),
+	apiKey: z.string().default(config.OPENAI_API_KEY),
 	defaultHeaders: z.record(z.string()).default({}),
 });
 

src/lib/server/embeddingEndpoints/tei/embeddingEndpoints.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import type { EmbeddingEndpoint, Embedding } from "../embeddingEndpoints";
 import { chunk } from "$lib/utils/chunk";
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import { logger } from "$lib/server/logger";
 
 export const embeddingEndpointTeiParametersSchema = z.object({
@@ -12,7 +12,7 @@ export const embeddingEndpointTeiParametersSchema = z.object({
 	authorization: z
 		.string()
 		.optional()
-		.transform((v) => (!v && env.HF_TOKEN ? "Bearer " + env.HF_TOKEN : v)), // if the header is not set but HF_TOKEN is, use it as the authorization header
+		.transform((v) => (!v && config.HF_TOKEN ? "Bearer " + config.HF_TOKEN : v)), // if the header is not set but HF_TOKEN is, use it as the authorization header
 });
 
 const getModelInfoByUrl = async (url: string, authorization?: string) => {

src/lib/server/embeddingModels.ts

@@ -1,4 +1,4 @@
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 
 import { z } from "zod";
 import { sum } from "$lib/utils/sum";
@@ -29,7 +29,7 @@ const modelConfig = z.object({
 
 // Default embedding model for backward compatibility
 const rawEmbeddingModelJSON =
-	env.TEXT_EMBEDDING_MODELS ||
+	config.TEXT_EMBEDDING_MODELS ||
 	`[
 	{
 	  "name": "Xenova/gte-small",

src/lib/server/endpoints/anthropic/endpointAnthropic.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import type { Endpoint } from "../endpoints";
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import type { TextGenerationStreamOutput } from "@huggingface/inference";
 import { createImageProcessorOptionsValidator } from "../images";
 import { endpointMessagesToAnthropicMessages, addToolResults } from "./utils";
@@ -22,7 +22,7 @@ export const endpointAnthropicParametersSchema = z.object({
 	model: z.any(),
 	type: z.literal("anthropic"),
 	baseURL: z.string().url().default("https://api.anthropic.com"),
-	apiKey: z.string().default(env.ANTHROPIC_API_KEY ?? "sk-"),
+	apiKey: z.string().default(config.ANTHROPIC_API_KEY ?? "sk-"),
 	defaultHeaders: z.record(z.string()).optional(),
 	defaultQuery: z.record(z.string()).optional(),
 	multimodal: z

src/lib/server/endpoints/cloudflare/endpointCloudflare.ts

@@ -1,15 +1,15 @@
 import { z } from "zod";
 import type { Endpoint } from "../endpoints";
 import type { TextGenerationStreamOutput } from "@huggingface/inference";
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import { logger } from "$lib/server/logger";
 
 export const endpointCloudflareParametersSchema = z.object({
 	weight: z.number().int().positive().default(1),
 	model: z.any(),
 	type: z.literal("cloudflare"),
-	accountId: z.string().default(env.CLOUDFLARE_ACCOUNT_ID),
-	apiToken: z.string().default(env.CLOUDFLARE_API_TOKEN),
+	accountId: z.string().default(config.CLOUDFLARE_ACCOUNT_ID),
+	apiToken: z.string().default(config.CLOUDFLARE_API_TOKEN),
 });
 
 export async function endpointCloudflare(

src/lib/server/endpoints/cohere/endpointCohere.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import type { Endpoint } from "../endpoints";
 import type { TextGenerationStreamOutput } from "@huggingface/inference";
 import type { Cohere, CohereClient } from "cohere-ai";
@@ -12,7 +12,7 @@ export const endpointCohereParametersSchema = z.object({
 	weight: z.number().int().positive().default(1),
 	model: z.any(),
 	type: z.literal("cohere"),
-	apiKey: z.string().default(env.COHERE_API_TOKEN),
+	apiKey: z.string().default(config.COHERE_API_TOKEN),
 	clientName: z.string().optional(),
 	raw: z.boolean().default(false),
 	forceSingleStep: z.boolean().default(true),

src/lib/server/endpoints/google/endpointGenAI.ts

@@ -6,13 +6,13 @@ import type { TextGenerationStreamOutput } from "@huggingface/inference";
 import type { Endpoint } from "../endpoints";
 import { createImageProcessorOptionsValidator, makeImageProcessor } from "../images";
 import type { ImageProcessorOptions } from "../images";
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 
 export const endpointGenAIParametersSchema = z.object({
 	weight: z.number().int().positive().default(1),
 	model: z.any(),
 	type: z.literal("genai"),
-	apiKey: z.string().default(env.GOOGLE_GENAI_API_KEY),
+	apiKey: z.string().default(config.GOOGLE_GENAI_API_KEY),
 	safetyThreshold: z
 		.enum([
 			HarmBlockThreshold.HARM_BLOCK_THRESHOLD_UNSPECIFIED,

src/lib/server/endpoints/llamacpp/endpointLlamacpp.ts

@@ -1,4 +1,4 @@
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import { buildPrompt } from "$lib/buildPrompt";
 import type { TextGenerationStreamOutput } from "@huggingface/inference";
 import type { Endpoint } from "../endpoints";
@@ -11,7 +11,7 @@ export const endpointLlamacppParametersSchema = z.object({
 	type: z.literal("llamacpp"),
 	url: z.string().url().default("http://127.0.0.1:8080"), // legacy, feel free to remove in breaking change update
 	baseURL: z.string().url().optional(),
-	accessToken: z.string().default(env.HF_TOKEN ?? env.HF_ACCESS_TOKEN),
+	accessToken: z.string().default(config.HF_TOKEN ?? config.HF_ACCESS_TOKEN),
 });
 
 export function endpointLlamacpp(

src/lib/server/endpoints/local/endpointLocal.ts

@@ -1,4 +1,4 @@
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import type {
 	Endpoint,
 	EndpointMessage,
@@ -50,7 +50,7 @@ export async function endpointLocal(
 	// Setup model path and folder
 	const path = modelPathInput ?? `hf:${model.id ?? model.name}`;
 	const modelFolder =
-		env.MODELS_STORAGE_PATH ||
+		config.MODELS_STORAGE_PATH ||
 		join(findRepoRoot(dirname(fileURLToPath(import.meta.url))), "models");
 
 	// Initialize Llama model

src/lib/server/endpoints/openai/endpointOai.ts

@@ -12,7 +12,7 @@ import type {
 } from "openai/resources/chat/completions";
 import type { FunctionDefinition, FunctionParameters } from "openai/resources/shared";
 import { buildPrompt } from "$lib/buildPrompt";
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import type { Endpoint } from "../endpoints";
 import type OpenAI from "openai";
 import { createImageProcessorOptionsValidator, makeImageProcessor } from "../images";
@@ -90,7 +90,7 @@ export const endpointOAIParametersSchema = z.object({
 	model: z.any(),
 	type: z.literal("openai"),
 	baseURL: z.string().url().default("https://api.openai.com/v1"),
-	apiKey: z.string().default(env.OPENAI_API_KEY || env.HF_TOKEN || "sk-"),
+	apiKey: z.string().default(config.OPENAI_API_KEY || config.HF_TOKEN || "sk-"),
 	completion: z
 		.union([z.literal("completions"), z.literal("chat_completions")])
 		.default("chat_completions"),

src/lib/server/endpoints/tgi/endpointTgi.ts

@@ -1,4 +1,4 @@
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import { buildPrompt } from "$lib/buildPrompt";
 import { textGenerationStream } from "@huggingface/inference";
 import type { Endpoint, EndpointMessage } from "../endpoints";
@@ -14,7 +14,7 @@ export const endpointTgiParametersSchema = z.object({
 	model: z.any(),
 	type: z.literal("tgi"),
 	url: z.string().url(),
-	accessToken: z.string().default(env.HF_TOKEN ?? env.HF_ACCESS_TOKEN),
+	accessToken: z.string().default(config.HF_TOKEN ?? config.HF_ACCESS_TOKEN),
 	authorization: z.string().optional(),
 	multimodal: z
 		.object({

src/lib/server/logger.ts

@@ -1,6 +1,6 @@
 import pino from "pino";
 import { dev } from "$app/environment";
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 
 let options: pino.LoggerOptions = {};
 
@@ -15,4 +15,4 @@ if (dev) {
 	};
 }
 
-export const logger = pino({ ...options, level: env.LOG_LEVEL ?? "info" });
+export const logger = pino({ ...options, level: config.LOG_LEVEL ?? "info" });

src/lib/server/metrics.ts

@@ -1,7 +1,7 @@
 import { collectDefaultMetrics, Registry, Counter, Summary } from "prom-client";
 import express from "express";
 import { logger } from "$lib/server/logger";
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import type { Model } from "$lib/types/Model";
 import { onExit } from "./exitHandler";
 import { promisify } from "util";
@@ -41,15 +41,15 @@ export class MetricsServer {
 	private constructor() {
 		const app = express();
 
-		const port = Number(env.METRICS_PORT || "5565");
+		const port = Number(config.METRICS_PORT || "5565");
 		if (isNaN(port) || port < 0 || port > 65535) {
-			logger.warn(`Invalid value for METRICS_PORT: ${env.METRICS_PORT}`);
+			logger.warn(`Invalid value for METRICS_PORT: ${config.METRICS_PORT}`);
 		}
 
-		if (env.METRICS_ENABLED !== "false" && env.METRICS_ENABLED !== "true") {
-			logger.warn(`Invalid value for METRICS_ENABLED: ${env.METRICS_ENABLED}`);
+		if (config.METRICS_ENABLED !== "false" && config.METRICS_ENABLED !== "true") {
+			logger.warn(`Invalid value for METRICS_ENABLED: ${config.METRICS_ENABLED}`);
 		}
-		if (env.METRICS_ENABLED === "true") {
+		if (config.METRICS_ENABLED === "true") {
 			const server = app.listen(port, () => {
 				logger.info(`Metrics server listening on port ${port}`);
 			});

src/lib/server/models.ts

@@ -1,4 +1,4 @@
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import type { ChatTemplateInput } from "$lib/types/Template";
 import { compileTemplate } from "$lib/utils/template";
 import { z } from "zod";
@@ -13,7 +13,6 @@ import JSON5 from "json5";
 import { getTokenizer } from "$lib/utils/getTokenizer";
 import { logger } from "$lib/server/logger";
 import { ToolResultStatus, type ToolInput } from "$lib/types/Tool";
-import { isHuggingChat } from "$lib/utils/isHuggingChat";
 import { join, dirname } from "path";
 import { resolveModelFile, readGgufFileInfo } from "node-llama-cpp";
 import { fileURLToPath } from "url";
@@ -22,7 +21,8 @@ import { Template } from "@huggingface/jinja";
 import { readdirSync } from "fs";
 
 export const MODELS_FOLDER =
-	env.MODELS_STORAGE_PATH || join(findRepoRoot(dirname(fileURLToPath(import.meta.url))), "models");
+	config.MODELS_STORAGE_PATH ||
+	join(findRepoRoot(dirname(fileURLToPath(import.meta.url))), "models");
 
 type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
 
@@ -137,9 +137,9 @@ const turnStringIntoLocalModel = z.preprocess((obj: unknown) => {
 	} satisfies z.input<typeof modelConfig>;
 }, modelConfig);
 
-let modelsRaw = z.array(turnStringIntoLocalModel).parse(JSON5.parse(env.MODELS ?? "[]"));
+let modelsRaw = z.array(turnStringIntoLocalModel).parse(JSON5.parse(config.MODELS ?? "[]"));
 
-if (env.LOAD_GGUF_MODELS === "true" || modelsRaw.length === 0) {
+if (config.LOAD_GGUF_MODELS === "true" || modelsRaw.length === 0) {
 	const parsedGgufModels = z.array(modelConfig).parse(ggufModelsConfig);
 	modelsRaw = [...modelsRaw, ...parsedGgufModels];
 }
@@ -240,7 +240,7 @@ async function getChatPromptRender(
 			// or use the `rag` mode without the citations
 			const id = m.id ?? m.name;
 
-			if (isHuggingChat && id.startsWith("CohereForAI")) {
+			if (config.isHuggingChat && id.startsWith("CohereForAI")) {
 				formattedMessages = [
 					{
 						role: "user",
@@ -267,7 +267,7 @@ async function getChatPromptRender(
 					},
 					...formattedMessages,
 				];
-			} else if (isHuggingChat && id.startsWith("meta-llama")) {
+			} else if (config.isHuggingChat && id.startsWith("meta-llama")) {
 				const results = toolResults.flatMap((result) => {
 					if (result.status === ToolResultStatus.Error) {
 						return [
@@ -361,8 +361,8 @@ const addEndpoint = (m: Awaited<ReturnType<typeof processModel>>) => ({
 		if (!m.endpoints) {
 			return endpointTgi({
 				type: "tgi",
-				url: `${env.HF_API_ROOT}/${m.name}`,
-				accessToken: env.HF_TOKEN ?? env.HF_ACCESS_TOKEN,
+				url: `${config.HF_API_ROOT}/${m.name}`,
+				accessToken: config.HF_TOKEN ?? config.HF_ACCESS_TOKEN,
 				weight: 1,
 				model: m,
 			});
@@ -416,7 +416,7 @@ const addEndpoint = (m: Awaited<ReturnType<typeof processModel>>) => ({
 	},
 });
 
-const inferenceApiIds = isHuggingChat
+const inferenceApiIds = config.isHuggingChat
 	? await fetch(
 			"https://huggingface.co/api/models?pipeline_tag=text-generation&inference=warm&filter=conversational"
 		)
@@ -447,7 +447,7 @@ export const validModelIdSchema = z.enum(models.map((m) => m.id) as [string, ...
 export const defaultModel = models[0];
 
 // Models that have been deprecated
-export const oldModels = env.OLD_MODELS
+export const oldModels = config.OLD_MODELS
 	? z
 			.array(
 				z.object({
@@ -457,7 +457,7 @@ export const oldModels = env.OLD_MODELS
 					transferTo: validModelIdSchema.optional(),
 				})
 			)
-			.parse(JSON5.parse(env.OLD_MODELS))
+			.parse(JSON5.parse(config.OLD_MODELS))
 			.map((m) => ({ ...m, id: m.id || m.name, displayName: m.displayName || m.name }))
 	: [];
 
@@ -469,9 +469,9 @@ export const validateModel = (_models: BackendModel[]) => {
 // if `TASK_MODEL` is string & name of a model in `MODELS`, then we use `MODELS[TASK_MODEL]`, else we try to parse `TASK_MODEL` as a model config itself
 
 export const taskModel = addEndpoint(
-	env.TASK_MODEL
-		? ((models.find((m) => m.name === env.TASK_MODEL) ||
-				(await processModel(modelConfig.parse(JSON5.parse(env.TASK_MODEL))))) ??
+	config.TASK_MODEL
+		? ((models.find((m) => m.name === config.TASK_MODEL) ||
+				(await processModel(modelConfig.parse(JSON5.parse(config.TASK_MODEL))))) ??
 				defaultModel)
 		: defaultModel
 );

src/lib/server/sendSlack.ts

@@ -1,13 +1,13 @@
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import { logger } from "$lib/server/logger";
 
 export async function sendSlack(text: string) {
-	if (!env.WEBHOOK_URL_REPORT_ASSISTANT) {
+	if (!config.WEBHOOK_URL_REPORT_ASSISTANT) {
 		logger.warn("WEBHOOK_URL_REPORT_ASSISTANT is not set, tried to send a slack message.");
 		return;
 	}
 
-	const res = await fetch(env.WEBHOOK_URL_REPORT_ASSISTANT, {
+	const res = await fetch(config.WEBHOOK_URL_REPORT_ASSISTANT, {
 		method: "POST",
 		headers: {
 			"Content-type": "application/json",

src/lib/server/textGeneration/assistant.ts

@@ -1,5 +1,5 @@
 import { isURLLocal } from "../isURLLocal";
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import { collections } from "$lib/server/database";
 import type { Assistant } from "$lib/types/Assistant";
 import type { ObjectId } from "mongodb";
@@ -20,7 +20,7 @@ export async function processPreprompt(preprompt: string, user_message: string |
 		const urlString = match[2];
 		try {
 			const url = new URL(urlString);
-			if ((await isURLLocal(url)) && env.ENABLE_LOCAL_FETCH !== "true") {
+			if ((await isURLLocal(url)) && config.ENABLE_LOCAL_FETCH !== "true") {
 				throw new Error("URL couldn't be fetched, it resolved to a local address.");
 			}
 
@@ -62,7 +62,7 @@ export async function getAssistantById(id?: ObjectId) {
 
 export function assistantHasWebSearch(assistant?: Pick<Assistant, "rag"> | null) {
 	return (
-		env.ENABLE_ASSISTANTS_RAG === "true" &&
+		config.ENABLE_ASSISTANTS_RAG === "true" &&
 		!!assistant?.rag &&
 		(assistant.rag.allowedLinks.length > 0 ||
 			assistant.rag.allowedDomains.length > 0 ||
@@ -71,5 +71,5 @@ export function assistantHasWebSearch(assistant?: Pick<Assistant, "rag"> | null)
 }
 
 export function assistantHasDynamicPrompt(assistant?: Pick<Assistant, "dynamicPrompt">) {
-	return env.ENABLE_ASSISTANTS_RAG === "true" && Boolean(assistant?.dynamicPrompt);
+	return config.ENABLE_ASSISTANTS_RAG === "true" && Boolean(assistant?.dynamicPrompt);
 }

src/lib/server/textGeneration/generate.ts

@@ -1,4 +1,4 @@
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import type { ToolResult, Tool } from "$lib/types/Tool";
 import {
 	MessageReasoningUpdateType,
@@ -171,7 +171,7 @@ Do not use prefixes such as Response: or Answer: when answering to the user.`,
 
 			// create a new status every 5 seconds
 			if (
-				env.REASONING_SUMMARY === "true" &&
+				config.REASONING_SUMMARY === "true" &&
 				new Date().getTime() - lastReasoningUpdate.getTime() > 4000
 			) {
 				lastReasoningUpdate = new Date();

src/lib/server/textGeneration/title.ts

@@ -1,4 +1,4 @@
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import { generateFromDefaultEndpoint } from "$lib/server/generateFromDefaultEndpoint";
 import { logger } from "$lib/server/logger";
 import { MessageUpdateType, type MessageUpdate } from "$lib/types/MessageUpdate";
@@ -29,7 +29,7 @@ export async function* generateTitleForConversation(
 }
 
 export async function generateTitle(prompt: string) {
-	if (env.LLM_SUMMARIZATION !== "true") {
+	if (config.LLM_SUMMARIZATION !== "true") {
 		return prompt.split(/\s+/g).slice(0, 5).join(" ");
 	}
 

src/lib/server/tools/index.ts

@@ -12,7 +12,7 @@ import type { TextGenerationContext } from "../textGeneration/types";
 
 import { z } from "zod";
 import JSON5 from "json5";
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 
 import jp from "jsonpath";
 import calculator from "./calculator";
@@ -306,4 +306,4 @@ export function getCallMethod(tool: Omit<BaseTool, "call">): BackendCall {
 	};
 }
 
-export const toolFromConfigs = configTools.parse(JSON5.parse(env.TOOLS)) satisfies ConfigTool[];
+export const toolFromConfigs = configTools.parse(JSON5.parse(config.TOOLS)) satisfies ConfigTool[];

src/lib/server/tools/utils.ts

@@ -1,4 +1,4 @@
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import { Client } from "@gradio/client";
 import { SignJWT } from "jose";
 import JSON5 from "json5";
@@ -28,7 +28,7 @@ export async function* callSpace<TInput extends unknown[], TOutput extends unkno
 	const client = await CustomClient.connect(name, {
 		hf_token: ipToken // dont pass the hf token if we have an ip token
 			? undefined
-			: ((env.HF_TOKEN ?? env.HF_ACCESS_TOKEN) as unknown as `hf_${string}`),
+			: ((config.HF_TOKEN ?? config.HF_ACCESS_TOKEN) as unknown as `hf_${string}`),
 		events: ["status", "data"],
 	});
 
@@ -63,7 +63,7 @@ export async function* callSpace<TInput extends unknown[], TOutput extends unkno
 }
 
 export async function getIpToken(ip: string, username?: string) {
-	const ipTokenSecret = env.IP_TOKEN_SECRET;
+	const ipTokenSecret = config.IP_TOKEN_SECRET;
 	if (!ipTokenSecret) {
 		return;
 	}

src/lib/server/usageLimits.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import JSON5 from "json5";
 
 // RATE_LIMIT is the legacy way to define messages per minute limit
@@ -12,7 +12,7 @@ export const usageLimitsSchema = z
 		messagesPerMinute: z
 			.preprocess((val) => {
 				if (val === undefined) {
-					return env.RATE_LIMIT;
+					return config.RATE_LIMIT;
 				}
 				return val;
 			}, z.coerce.number().optional())
@@ -21,4 +21,4 @@ export const usageLimitsSchema = z
 	})
 	.optional();
 
-export const usageLimits = usageLimitsSchema.parse(JSON5.parse(env.USAGE_LIMITS));
+export const usageLimits = usageLimitsSchema.parse(JSON5.parse(config.USAGE_LIMITS));

src/lib/server/websearch/scrape/playwright.ts

@@ -7,16 +7,16 @@ import {
 	type Browser,
 } from "playwright";
 import { PlaywrightBlocker } from "@cliqz/adblocker-playwright";
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import { logger } from "$lib/server/logger";
 import { onExit } from "$lib/server/exitHandler";
 
 const blocker =
-	env.PLAYWRIGHT_ADBLOCKER === "true"
+	config.PLAYWRIGHT_ADBLOCKER === "true"
 		? await PlaywrightBlocker.fromPrebuiltAdsAndTracking(fetch)
 				.then((blker) => {
 					const mostBlocked = blker.blockFonts().blockMedias().blockFrames().blockImages();
-					if (env.WEBSEARCH_JAVASCRIPT === "false") return mostBlocked.blockScripts();
+					if (config.WEBSEARCH_JAVASCRIPT === "false") return mostBlocked.blockScripts();
 					return mostBlocked;
 				})
 				.catch((err) => {
@@ -68,7 +68,7 @@ export async function withPage<T>(
 
 	try {
 		const page = await ctx.newPage();
-		if (env.PLAYWRIGHT_ADBLOCKER === "true") {
+		if (config.PLAYWRIGHT_ADBLOCKER === "true") {
 			await blocker.enableBlockingInPage(page);
 		}
 
@@ -82,10 +82,10 @@ export async function withPage<T>(
 		});
 
 		const res = await page
-			.goto(url, { waitUntil: "load", timeout: parseInt(env.WEBSEARCH_TIMEOUT) })
+			.goto(url, { waitUntil: "load", timeout: parseInt(config.WEBSEARCH_TIMEOUT) })
 			.catch(() => {
 				console.warn(
-					`Failed to load page within ${parseInt(env.WEBSEARCH_TIMEOUT) / 1000}s: ${url}`
+					`Failed to load page within ${parseInt(config.WEBSEARCH_TIMEOUT) / 1000}s: ${url}`
 				);
 			});
 

src/lib/server/websearch/search/endpoints.ts

@@ -1,5 +1,5 @@
 import { WebSearchProvider, type WebSearchSource } from "$lib/types/WebSearch";
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import searchSerper from "./endpoints/serper";
 import searchSerpApi from "./endpoints/serpApi";
 import searchSerpStack from "./endpoints/serpStack";
@@ -10,22 +10,22 @@ import searchSearchApi from "./endpoints/searchApi";
 import searchBing from "./endpoints/bing";
 
 export function getWebSearchProvider() {
-	if (env.YDC_API_KEY) return WebSearchProvider.YOU;
-	if (env.SEARXNG_QUERY_URL) return WebSearchProvider.SEARXNG;
-	if (env.BING_SUBSCRIPTION_KEY) return WebSearchProvider.BING;
+	if (config.YDC_API_KEY) return WebSearchProvider.YOU;
+	if (config.SEARXNG_QUERY_URL) return WebSearchProvider.SEARXNG;
+	if (config.BING_SUBSCRIPTION_KEY) return WebSearchProvider.BING;
 	return WebSearchProvider.GOOGLE;
 }
 
 /** Searches the web using the first available provider, based on the env */
 export async function searchWeb(query: string): Promise<WebSearchSource[]> {
-	if (env.USE_LOCAL_WEBSEARCH) return searchWebLocal(query);
-	if (env.SEARXNG_QUERY_URL) return searchSearxng(query);
-	if (env.SERPER_API_KEY) return searchSerper(query);
-	if (env.YDC_API_KEY) return searchYouApi(query);
-	if (env.SERPAPI_KEY) return searchSerpApi(query);
-	if (env.SERPSTACK_API_KEY) return searchSerpStack(query);
-	if (env.SEARCHAPI_KEY) return searchSearchApi(query);
-	if (env.BING_SUBSCRIPTION_KEY) return searchBing(query);
+	if (config.USE_LOCAL_WEBSEARCH) return searchWebLocal(query);
+	if (config.SEARXNG_QUERY_URL) return searchSearxng(query);
+	if (config.SERPER_API_KEY) return searchSerper(query);
+	if (config.YDC_API_KEY) return searchYouApi(query);
+	if (config.SERPAPI_KEY) return searchSerpApi(query);
+	if (config.SERPSTACK_API_KEY) return searchSerpStack(query);
+	if (config.SEARCHAPI_KEY) return searchSearchApi(query);
+	if (config.BING_SUBSCRIPTION_KEY) return searchBing(query);
 	throw new Error(
 		"No configuration found for web search. Please set USE_LOCAL_WEBSEARCH, SEARXNG_QUERY_URL, SERPER_API_KEY, YDC_API_KEY, SERPSTACK_API_KEY, or SEARCHAPI_KEY in your environment variables."
 	);

src/lib/server/websearch/search/endpoints/bing.ts

@@ -1,5 +1,5 @@
 import type { WebSearchSource } from "$lib/types/WebSearch";
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 
 export default async function search(query: string): Promise<WebSearchSource[]> {
 	// const params = {
@@ -12,7 +12,7 @@ export default async function search(query: string): Promise<WebSearchSource[]>
 		{
 			method: "GET",
 			headers: {
-				"Ocp-Apim-Subscription-Key": env.BING_SUBSCRIPTION_KEY,
+				"Ocp-Apim-Subscription-Key": config.BING_SUBSCRIPTION_KEY,
 				"Content-type": "application/json",
 			},
 		}

src/lib/server/websearch/search/endpoints/searchApi.ts

@@ -1,4 +1,4 @@
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import type { WebSearchSource } from "$lib/types/WebSearch";
 
 export default async function search(query: string): Promise<WebSearchSource[]> {
@@ -7,7 +7,7 @@ export default async function search(query: string): Promise<WebSearchSource[]>
 		{
 			method: "GET",
 			headers: {
-				Authorization: `Bearer ${env.SEARCHAPI_KEY}`,
+				Authorization: `Bearer ${config.SEARCHAPI_KEY}`,
 				"Content-type": "application/json",
 			},
 		}

src/lib/server/websearch/search/endpoints/searxng.ts

@@ -1,4 +1,4 @@
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import { logger } from "$lib/server/logger";
 import type { WebSearchSource } from "$lib/types/WebSearch";
 import { isURL } from "$lib/utils/isUrl";
@@ -8,7 +8,7 @@ export default async function searchSearxng(query: string): Promise<WebSearchSou
 	setTimeout(() => abortController.abort(), 10000);
 
 	// Insert the query into the URL template
-	let url = env.SEARXNG_QUERY_URL.replace("<query>", query);
+	let url = config.SEARXNG_QUERY_URL.replace("<query>", query);
 
 	// Check if "&format=json" already exists in the URL
 	if (!url.includes("&format=json")) {

src/lib/server/websearch/search/endpoints/serpApi.ts

@@ -1,4 +1,4 @@
-import { env } from "$env/dynamic/private";
+import { config } from "$lib/server/config";
 import { getJson, type GoogleParameters } from "serpapi";
 import type { WebSearchSource } from "$lib/types/WebSearch";
 import { isURL } from "$lib/utils/isUrl";
@@ -15,7 +15,7 @@ export default async function searchWebSerpApi(query: string): Promise<WebSearch
 		hl: "en",
 		gl: "us",
 		google_domain: "google.com",
-		api_key: env.SERPAPI_KEY,
+		api_key: config.SERPAPI_KEY,
 	} satisfies GoogleParameters;
 
 	// Show result as JSON