ruflo 3.5.2 → 3.5.3

package/src/ruvocal/src/lib/server/config.ts

@@ -0,0 +1,187 @@
+import { env as publicEnv } from "$env/dynamic/public";
+import { env as serverEnv } from "$env/dynamic/private";
+import { building } from "$app/environment";
+import type { RvfCollection } from "$lib/server/database/rvf";
+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: RvfCollection<ConfigKeyType> | undefined;
+	private semaphoreCollection: RvfCollection<Semaphore> | undefined;
+	private lastConfigUpdate: Date | undefined;
+
+	async init() {
+		if (this.isInitialized) return;
+
+		if (building || import.meta.env.MODE === "test") {
+			this.isInitialized = true;
+			return;
+		}
+
+		const { getCollectionsEarly } = await import("./database");
+		const collections = await getCollectionsEarly();
+
+		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();
+	}
+})();
+
+type ExtraConfigKeys =
+	| "HF_TOKEN"
+	| "OLD_MODELS"
+	| "ENABLE_ASSISTANTS"
+	| "METRICS_ENABLED"
+	| "METRICS_PORT"
+	| "MCP_SERVERS"
+	| "MCP_FORWARD_HF_USER_TOKEN"
+	| "MCP_TOOL_TIMEOUT_MS"
+	| "EXA_API_KEY";
+
+type ConfigProxy = ConfigManager & { [K in ConfigKey | ExtraConfigKeys]: 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;

package/src/ruvocal/src/lib/server/conversation.ts

@@ -0,0 +1,83 @@
+import { collections } from "$lib/server/database";
+import { MetricsServer } from "$lib/server/metrics";
+import { error } from "@sveltejs/kit";
+import { ObjectId } from "mongodb";
+import { authCondition } from "$lib/server/auth";
+
+/**
+ * Create a new conversation from a shared conversation ID.
+ * If the conversation already exists for the user/session, return the existing conversation ID.
+ * returns the conversation ID.
+ */
+export async function createConversationFromShare(
+	fromShareId: string,
+	locals: App.Locals,
+	userAgent?: string
+): Promise<string> {
+	const conversation = await collections.sharedConversations.findOne({
+		_id: fromShareId,
+	});
+
+	if (!conversation) {
+		error(404, "Conversation not found");
+	}
+
+	// Check if shared conversation exists already for this user/session
+	const existingConversation = await collections.conversations.findOne({
+		"meta.fromShareId": fromShareId,
+		...authCondition(locals),
+	});
+
+	if (existingConversation) {
+		return existingConversation._id.toString();
+	}
+
+	// Create new conversation from shared conversation
+	const res = await collections.conversations.insertOne({
+		_id: new ObjectId(),
+		title: conversation.title.replace(/<\/?think>/gi, "").trim(),
+		rootMessageId: conversation.rootMessageId,
+		messages: conversation.messages,
+		model: conversation.model,
+		preprompt: conversation.preprompt,
+		createdAt: new Date(),
+		updatedAt: new Date(),
+		userAgent,
+		...(locals.user ? { userId: locals.user._id } : { sessionId: locals.sessionId }),
+		meta: { fromShareId },
+	});
+
+	// Copy files from shared conversation bucket entries to the new conversation
+	// Shared files are stored with filenames "${sharedId}-${sha}" and metadata.conversation = sharedId
+	// New conversation expects files to be stored under its own id prefix
+	const newConvId = res.insertedId.toString();
+	const sharedId = fromShareId;
+	const files = await collections.bucket.find({ filename: { $regex: `^${sharedId}-` } }).toArray();
+
+	await Promise.all(
+		files.map(
+			(file) =>
+				new Promise<void>((resolve, reject) => {
+					try {
+						const newFilename = file.filename.replace(`${sharedId}-`, `${newConvId}-`);
+						const downloadStream = collections.bucket.openDownloadStream(file._id);
+						const uploadStream = collections.bucket.openUploadStream(newFilename, {
+							metadata: { ...file.metadata, conversation: newConvId },
+						});
+						downloadStream
+							.on("error", reject)
+							.pipe(uploadStream)
+							.on("error", reject)
+							.on("finish", () => resolve());
+					} catch (e) {
+						reject(e);
+					}
+				})
+		)
+	);
+
+	if (MetricsServer.isEnabled()) {
+		MetricsServer.getMetrics().model.conversationsTotal.inc({ model: conversation.model });
+	}
+	return res.insertedId.toString();
+}