ruflo 3.5.2 → 3.5.3

package/src/ruvocal/src/routes/api/v2/conversations/import-share/+server.ts

@@ -0,0 +1,23 @@
+import { error, type RequestHandler } from "@sveltejs/kit";
+import { superjsonResponse } from "$lib/server/api/utils/superjsonResponse";
+import { requireAuth } from "$lib/server/api/utils/requireAuth";
+import { createConversationFromShare } from "$lib/server/conversation";
+
+export const POST: RequestHandler = async ({ locals, request }) => {
+	requireAuth(locals);
+
+	const body = await request.json();
+	const shareId = body?.shareId;
+
+	if (!shareId || typeof shareId !== "string" || shareId.length === 0) {
+		error(400, "shareId is required");
+	}
+
+	const conversationId = await createConversationFromShare(
+		shareId,
+		locals,
+		request.headers.get("User-Agent") ?? undefined
+	);
+
+	return superjsonResponse({ conversationId });
+};

package/src/ruvocal/src/routes/api/v2/debug/config/+server.ts

@@ -0,0 +1,16 @@
+import type { RequestHandler } from "@sveltejs/kit";
+import { superjsonResponse } from "$lib/server/api/utils/superjsonResponse";
+import { config } from "$lib/server/config";
+import { requireAdmin } from "$lib/server/api/utils/requireAuth";
+
+export const GET: RequestHandler = async ({ locals }) => {
+	requireAdmin(locals);
+	const { models } = await import("$lib/server/models");
+	return superjsonResponse({
+		OPENAI_BASE_URL: config.OPENAI_BASE_URL,
+		OPENAI_API_KEY_SET: Boolean(config.OPENAI_API_KEY || config.HF_TOKEN),
+		LEGACY_HF_TOKEN_SET: Boolean(config.HF_TOKEN && !config.OPENAI_API_KEY),
+		MODELS_COUNT: models.length,
+		NODE_VERSION: process.versions.node,
+	});
+};

package/src/ruvocal/src/routes/api/v2/debug/refresh/+server.ts

@@ -0,0 +1,30 @@
+import type { RequestHandler } from "@sveltejs/kit";
+import { superjsonResponse } from "$lib/server/api/utils/superjsonResponse";
+import { config } from "$lib/server/config";
+import { requireAdmin } from "$lib/server/api/utils/requireAuth";
+
+export const GET: RequestHandler = async ({ locals }) => {
+	requireAdmin(locals);
+	const base = (config.OPENAI_BASE_URL || "https://router.huggingface.co/v1").replace(/\/$/, "");
+	const res = await fetch(`${base}/models`);
+	const body = await res.text();
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(body);
+	} catch {
+		parsed = undefined;
+	}
+	return superjsonResponse({
+		status: res.status,
+		ok: res.ok,
+		base,
+		length: (() => {
+			if (parsed && typeof parsed === "object" && "data" in parsed) {
+				const data = (parsed as { data?: unknown }).data;
+				return Array.isArray(data) ? data.length : null;
+			}
+			return null;
+		})(),
+		sample: body.slice(0, 2000),
+	});
+};

package/src/ruvocal/src/routes/api/v2/export/+server.ts

@@ -0,0 +1,196 @@
+import { error, type RequestHandler } from "@sveltejs/kit";
+import { collections } from "$lib/server/database";
+import { authCondition } from "$lib/server/auth";
+import { config } from "$lib/server/config";
+import yazl from "yazl";
+import { downloadFile } from "$lib/server/files/downloadFile";
+import mimeTypes from "mime-types";
+import { logger } from "$lib/server/logger";
+
+export const GET: RequestHandler = async ({ locals }) => {
+	if (!locals.user) {
+		error(401, "Not logged in");
+	}
+
+	if (!locals.isAdmin) {
+		error(403, "Not admin");
+	}
+
+	if (config.ENABLE_DATA_EXPORT !== "true") {
+		error(403, "Data export is not enabled");
+	}
+
+	const nExports = await collections.messageEvents.countDocuments({
+		userId: locals.user._id,
+		type: "export",
+		expiresAt: { $gt: new Date() },
+	});
+
+	if (nExports >= 1) {
+		error(
+			429,
+			"You have already exported your data recently. Please wait 1 hour before exporting again."
+		);
+	}
+
+	const stats: {
+		nConversations: number;
+		nMessages: number;
+		nFiles: number;
+		nAssistants: number;
+		nAvatars: number;
+	} = {
+		nConversations: 0,
+		nMessages: 0,
+		nFiles: 0,
+		nAssistants: 0,
+		nAvatars: 0,
+	};
+
+	const zipfile = new yazl.ZipFile();
+
+	const promises = [
+		collections.conversations
+			.find({ ...authCondition(locals) })
+			.toArray()
+			.then(async (conversations) => {
+				const formattedConversations = await Promise.all(
+					conversations.map(async (conversation) => {
+						stats.nConversations++;
+						const hashes: string[] = [];
+						conversation.messages.forEach(async (message) => {
+							stats.nMessages++;
+							if (message.files) {
+								message.files.forEach((file) => {
+									hashes.push(file.value);
+								});
+							}
+						});
+						const files = await Promise.all(
+							hashes.map(async (hash) => {
+								try {
+									const fileData = await downloadFile(hash, conversation._id);
+									return fileData;
+								} catch {
+									return null;
+								}
+							})
+						);
+
+						const filenames: string[] = [];
+						files.forEach((file) => {
+							if (!file) return;
+
+							const extension = mimeTypes.extension(file.mime) || null;
+							const convId = conversation._id.toString();
+							const fileId = file.name.split("-")[1].slice(0, 8);
+							const fileName = `file-${convId}-${fileId}` + (extension ? `.${extension}` : "");
+							filenames.push(fileName);
+							zipfile.addBuffer(Buffer.from(file.value, "base64"), fileName);
+							stats.nFiles++;
+						});
+
+						return {
+							...conversation,
+							messages: conversation.messages.map((message) => {
+								return {
+									...message,
+									files: filenames,
+									updates: undefined,
+								};
+							}),
+						};
+					})
+				);
+
+				zipfile.addBuffer(
+					Buffer.from(JSON.stringify(formattedConversations, null, 2)),
+					"conversations.json"
+				);
+			}),
+		collections.assistants
+			.find({ createdById: locals.user._id })
+			.toArray()
+			.then(async (assistants) => {
+				const formattedAssistants = await Promise.all(
+					assistants.map(async (assistant) => {
+						if (assistant.avatar) {
+							const fileId = collections.bucket.find({
+								filename: assistant._id.toString(),
+							});
+
+							const content = await fileId.next().then(async (file) => {
+								if (!file?._id) return;
+
+								const fileStream = collections.bucket.openDownloadStream(file?._id);
+
+								const fileBuffer = await new Promise<Buffer>((resolve, reject) => {
+									const chunks: Uint8Array[] = [];
+									fileStream.on("data", (chunk) => chunks.push(chunk));
+									fileStream.on("error", reject);
+									fileStream.on("end", () => resolve(Buffer.concat(chunks)));
+								});
+
+								return fileBuffer;
+							});
+
+							if (!content) return;
+
+							zipfile.addBuffer(content, `avatar-${assistant._id.toString()}.jpg`);
+							stats.nAvatars++;
+						}
+
+						stats.nAssistants++;
+
+						return {
+							_id: assistant._id.toString(),
+							name: assistant.name,
+							createdById: assistant.createdById.toString(),
+							createdByName: assistant.createdByName,
+							avatar: `avatar-${assistant._id.toString()}.jpg`,
+							modelId: assistant.modelId,
+							preprompt: assistant.preprompt,
+							description: assistant.description,
+							dynamicPrompt: assistant.dynamicPrompt,
+							exampleInputs: assistant.exampleInputs,
+							generateSettings: assistant.generateSettings,
+							createdAt: assistant.createdAt.toISOString(),
+							updatedAt: assistant.updatedAt.toISOString(),
+						};
+					})
+				);
+
+				zipfile.addBuffer(
+					Buffer.from(JSON.stringify(formattedAssistants, null, 2)),
+					"assistants.json"
+				);
+			}),
+	];
+
+	Promise.all(promises).then(async () => {
+		logger.info(
+			{
+				userId: locals.user?._id,
+				...stats,
+			},
+			"Exported user data"
+		);
+		zipfile.end();
+		if (locals.user?._id) {
+			await collections.messageEvents.insertOne({
+				userId: locals.user?._id,
+				type: "export",
+				createdAt: new Date(),
+				expiresAt: new Date(Date.now() + 1000 * 60 * 60), // 1 hour
+			});
+		}
+	});
+
+	// @ts-expect-error - zipfile.outputStream is not typed correctly
+	return new Response(zipfile.outputStream, {
+		headers: {
+			"Content-Type": "application/zip",
+			"Content-Disposition": 'attachment; filename="export.zip"',
+		},
+	});
+};

package/src/ruvocal/src/routes/api/v2/feature-flags/+server.ts

@@ -0,0 +1,14 @@
+import type { RequestHandler } from "@sveltejs/kit";
+import { superjsonResponse } from "$lib/server/api/utils/superjsonResponse";
+import { loginEnabled } from "$lib/server/auth";
+import { config } from "$lib/server/config";
+import type { FeatureFlags } from "$lib/server/api/types";
+
+export const GET: RequestHandler = async ({ locals }) => {
+	return superjsonResponse({
+		enableAssistants: config.ENABLE_ASSISTANTS === "true",
+		loginEnabled,
+		isAdmin: locals.isAdmin,
+		transcriptionEnabled: !!config.get("TRANSCRIPTION_MODEL"),
+	} satisfies FeatureFlags);
+};

package/src/ruvocal/src/routes/api/v2/models/+server.ts

@@ -0,0 +1,38 @@
+import type { RequestHandler } from "@sveltejs/kit";
+import { superjsonResponse } from "$lib/server/api/utils/superjsonResponse";
+import type { GETModelsResponse } from "$lib/server/api/types";
+
+export const GET: RequestHandler = async () => {
+	try {
+		const { models } = await import("$lib/server/models");
+		return superjsonResponse(
+			models
+				.filter((m) => m.unlisted == false)
+				.map((model) => ({
+					id: model.id,
+					name: model.name,
+					websiteUrl: model.websiteUrl,
+					modelUrl: model.modelUrl,
+					datasetName: model.datasetName,
+					datasetUrl: model.datasetUrl,
+					displayName: model.displayName,
+					description: model.description,
+					logoUrl: model.logoUrl,
+					providers: model.providers as unknown as Array<
+						{ provider: string } & Record<string, unknown>
+					>,
+					promptExamples: model.promptExamples,
+					parameters: model.parameters,
+					preprompt: model.preprompt,
+					multimodal: model.multimodal,
+					multimodalAcceptedMimetypes: model.multimodalAcceptedMimetypes,
+					supportsTools: (model as unknown as { supportsTools?: boolean }).supportsTools ?? false,
+					unlisted: model.unlisted,
+					hasInferenceAPI: model.hasInferenceAPI,
+					isRouter: model.isRouter,
+				})) satisfies GETModelsResponse
+		);
+	} catch {
+		return superjsonResponse([] as GETModelsResponse);
+	}
+};

package/src/ruvocal/src/routes/api/v2/models/[namespace]/+server.ts

@@ -0,0 +1,8 @@
+import type { RequestHandler } from "@sveltejs/kit";
+import { superjsonResponse } from "$lib/server/api/utils/superjsonResponse";
+import { resolveModel } from "$lib/server/api/utils/resolveModel";
+
+export const GET: RequestHandler = async ({ params }) => {
+	const model = await resolveModel(params.namespace ?? "");
+	return superjsonResponse(model);
+};

package/src/ruvocal/src/routes/api/v2/models/[namespace]/[model]/+server.ts

@@ -0,0 +1,8 @@
+import type { RequestHandler } from "@sveltejs/kit";
+import { superjsonResponse } from "$lib/server/api/utils/superjsonResponse";
+import { resolveModel } from "$lib/server/api/utils/resolveModel";
+
+export const GET: RequestHandler = async ({ params }) => {
+	const model = await resolveModel(params.namespace ?? "", params.model ?? "");
+	return superjsonResponse(model);
+};

package/src/ruvocal/src/routes/api/v2/models/[namespace]/[model]/subscribe/+server.ts

@@ -0,0 +1,28 @@
+import { error, type RequestHandler } from "@sveltejs/kit";
+import { resolveModel } from "$lib/server/api/utils/resolveModel";
+import { collections } from "$lib/server/database";
+import { authCondition } from "$lib/server/auth";
+
+export const POST: RequestHandler = async ({ params, locals }) => {
+	if (!locals.sessionId) {
+		error(401, "Unauthorized");
+	}
+
+	const model = await resolveModel(params.namespace ?? "", params.model ?? "");
+
+	await collections.settings.updateOne(
+		authCondition(locals),
+		{
+			$set: {
+				activeModel: model.id,
+				updatedAt: new Date(),
+			},
+			$setOnInsert: {
+				createdAt: new Date(),
+			},
+		},
+		{ upsert: true }
+	);
+
+	return new Response();
+};

package/src/ruvocal/src/routes/api/v2/models/[namespace]/subscribe/+server.ts

@@ -0,0 +1,28 @@
+import { error, type RequestHandler } from "@sveltejs/kit";
+import { resolveModel } from "$lib/server/api/utils/resolveModel";
+import { collections } from "$lib/server/database";
+import { authCondition } from "$lib/server/auth";
+
+export const POST: RequestHandler = async ({ params, locals }) => {
+	if (!locals.sessionId) {
+		error(401, "Unauthorized");
+	}
+
+	const model = await resolveModel(params.namespace ?? "");
+
+	await collections.settings.updateOne(
+		authCondition(locals),
+		{
+			$set: {
+				activeModel: model.id,
+				updatedAt: new Date(),
+			},
+			$setOnInsert: {
+				createdAt: new Date(),
+			},
+		},
+		{ upsert: true }
+	);
+
+	return new Response();
+};

package/src/ruvocal/src/routes/api/v2/models/old/+server.ts

@@ -0,0 +1,7 @@
+import type { RequestHandler } from "@sveltejs/kit";
+import { superjsonResponse } from "$lib/server/api/utils/superjsonResponse";
+import type { GETOldModelsResponse } from "$lib/server/api/types";
+
+export const GET: RequestHandler = async () => {
+	return superjsonResponse([] as GETOldModelsResponse);
+};

package/src/ruvocal/src/routes/api/v2/models/refresh/+server.ts

@@ -0,0 +1,33 @@
+import { error, type RequestHandler } from "@sveltejs/kit";
+import { superjsonResponse } from "$lib/server/api/utils/superjsonResponse";
+import { requireAdmin } from "$lib/server/api/utils/requireAuth";
+import { refreshModels, lastModelRefreshSummary } from "$lib/server/models";
+
+export const POST: RequestHandler = async ({ locals }) => {
+	requireAdmin(locals);
+
+	const previous = lastModelRefreshSummary;
+
+	try {
+		const summary = await refreshModels();
+		return superjsonResponse({
+			refreshedAt: summary.refreshedAt.toISOString(),
+			durationMs: summary.durationMs,
+			added: summary.added,
+			removed: summary.removed,
+			changed: summary.changed,
+			total: summary.total,
+			hadChanges:
+				summary.added.length > 0 || summary.removed.length > 0 || summary.changed.length > 0,
+			previous:
+				previous.refreshedAt.getTime() > 0
+					? {
+							refreshedAt: previous.refreshedAt.toISOString(),
+							total: previous.total,
+						}
+					: null,
+		});
+	} catch {
+		error(502, "Model refresh failed");
+	}
+};

package/src/ruvocal/src/routes/api/v2/public-config/+server.ts

@@ -0,0 +1,7 @@
+import type { RequestHandler } from "@sveltejs/kit";
+import { superjsonResponse } from "$lib/server/api/utils/superjsonResponse";
+import { config } from "$lib/server/config";
+
+export const GET: RequestHandler = async () => {
+	return superjsonResponse(await config.getPublicConfig());
+};

package/src/ruvocal/src/routes/api/v2/user/+server.ts

@@ -0,0 +1,17 @@
+import type { RequestHandler } from "@sveltejs/kit";
+import { superjsonResponse } from "$lib/server/api/utils/superjsonResponse";
+
+export const GET: RequestHandler = async ({ locals }) => {
+	return superjsonResponse(
+		locals.user
+			? {
+					id: locals.user._id.toString(),
+					username: locals.user.username,
+					avatarUrl: locals.user.avatarUrl,
+					email: locals.user.email,
+					isAdmin: locals.user.isAdmin ?? false,
+					isEarlyAccess: locals.user.isEarlyAccess ?? false,
+				}
+			: null
+	);
+};

package/src/ruvocal/src/routes/api/v2/user/billing-orgs/+server.ts

@@ -0,0 +1,73 @@
+import { error, type RequestHandler } from "@sveltejs/kit";
+import { superjsonResponse } from "$lib/server/api/utils/superjsonResponse";
+import { config } from "$lib/server/config";
+import { collections } from "$lib/server/database";
+import { authCondition } from "$lib/server/auth";
+import { logger } from "$lib/server/logger";
+
+export const GET: RequestHandler = async ({ locals }) => {
+	if (!config.isHuggingChat) {
+		error(404, "Not available");
+	}
+
+	if (!locals.user) {
+		error(401, "Login required");
+	}
+
+	if (!locals.token) {
+		error(401, "OAuth token not available. Please log out and log back in.");
+	}
+
+	try {
+		const response = await fetch("https://huggingface.co/oauth/userinfo", {
+			headers: { Authorization: `Bearer ${locals.token}` },
+		});
+
+		if (!response.ok) {
+			logger.error(`Failed to fetch billing orgs: ${response.status}`);
+			error(502, "Failed to fetch billing information");
+		}
+
+		const data = await response.json();
+
+		const settings = await collections.settings.findOne(authCondition(locals));
+		const currentBillingOrg = settings?.billingOrganization;
+
+		const billingOrgs = (data.orgs ?? [])
+			.filter((org: { canPay?: boolean }) => org.canPay === true)
+			.map((org: { sub: string; name: string; preferred_username: string }) => ({
+				sub: org.sub,
+				name: org.name,
+				preferred_username: org.preferred_username,
+			}));
+
+		const isCurrentOrgValid =
+			!currentBillingOrg ||
+			billingOrgs.some(
+				(org: { preferred_username: string }) => org.preferred_username === currentBillingOrg
+			);
+
+		if (!isCurrentOrgValid && currentBillingOrg) {
+			logger.info(
+				`Clearing invalid billingOrganization '${currentBillingOrg}' for user ${locals.user._id}`
+			);
+			await collections.settings.updateOne(authCondition(locals), {
+				$unset: { billingOrganization: "" },
+				$set: { updatedAt: new Date() },
+			});
+		}
+
+		return superjsonResponse({
+			userCanPay: data.canPay ?? false,
+			organizations: billingOrgs,
+			currentBillingOrg: isCurrentOrgValid ? currentBillingOrg : undefined,
+		});
+	} catch (err) {
+		// Re-throw SvelteKit HttpErrors
+		if (err && typeof err === "object" && "status" in err) {
+			throw err;
+		}
+		logger.error(err, "Error fetching billing orgs:");
+		error(500, "Internal server error");
+	}
+};

package/src/ruvocal/src/routes/api/v2/user/reports/+server.ts

@@ -0,0 +1,17 @@
+import type { RequestHandler } from "@sveltejs/kit";
+import { superjsonResponse } from "$lib/server/api/utils/superjsonResponse";
+import { collections } from "$lib/server/database";
+
+export const GET: RequestHandler = async ({ locals }) => {
+	if (!locals.user || !locals.sessionId) {
+		return superjsonResponse([]);
+	}
+
+	const reports = await collections.reports
+		.find({
+			createdBy: locals.user?._id ?? locals.sessionId,
+		})
+		.toArray();
+
+	return superjsonResponse(reports);
+};

package/src/ruvocal/src/routes/api/v2/user/settings/+server.ts

@@ -0,0 +1,103 @@
+import type { RequestHandler } from "@sveltejs/kit";
+import { superjsonResponse } from "$lib/server/api/utils/superjsonResponse";
+import { collections } from "$lib/server/database";
+import { authCondition } from "$lib/server/auth";
+import { requireAuth } from "$lib/server/api/utils/requireAuth";
+import { defaultModel, models, validateModel } from "$lib/server/models";
+import { DEFAULT_SETTINGS, type SettingsEditable } from "$lib/types/Settings";
+import { resolveStreamingMode } from "$lib/utils/messageUpdates";
+import { z } from "zod";
+
+const settingsSchema = z.object({
+	shareConversationsWithModelAuthors: z
+		.boolean()
+		.default(DEFAULT_SETTINGS.shareConversationsWithModelAuthors),
+	welcomeModalSeen: z.boolean().optional(),
+	activeModel: z.string().default(DEFAULT_SETTINGS.activeModel),
+	customPrompts: z.record(z.string()).default({}),
+	multimodalOverrides: z.record(z.boolean()).default({}),
+	toolsOverrides: z.record(z.boolean()).default({}),
+	providerOverrides: z.record(z.string()).default({}),
+	streamingMode: z.enum(["raw", "smooth"]).optional(),
+	directPaste: z.boolean().default(false),
+	hapticsEnabled: z.boolean().default(true),
+	hidePromptExamples: z.record(z.boolean()).default({}),
+	autopilotEnabled: z.boolean().default(true),
+	billingOrganization: z.string().optional(),
+});
+
+export const GET: RequestHandler = async ({ locals }) => {
+	requireAuth(locals);
+	const settings = await collections.settings.findOne(authCondition(locals));
+
+	if (settings && !validateModel(models).safeParse(settings?.activeModel).success) {
+		settings.activeModel = defaultModel.id;
+		await collections.settings.updateOne(authCondition(locals), {
+			$set: { activeModel: defaultModel.id },
+		});
+	}
+
+	// if the model is unlisted, set the active model to the default model
+	if (
+		settings?.activeModel &&
+		models.find((m) => m.id === settings?.activeModel)?.unlisted === true
+	) {
+		settings.activeModel = defaultModel.id;
+		await collections.settings.updateOne(authCondition(locals), {
+			$set: { activeModel: defaultModel.id },
+		});
+	}
+
+	const streamingMode = resolveStreamingMode(settings ?? {});
+
+	return superjsonResponse({
+		welcomeModalSeen: !!settings?.welcomeModalSeenAt,
+		welcomeModalSeenAt: settings?.welcomeModalSeenAt ?? null,
+
+		activeModel: settings?.activeModel ?? DEFAULT_SETTINGS.activeModel,
+		streamingMode,
+		directPaste: settings?.directPaste ?? DEFAULT_SETTINGS.directPaste,
+		hapticsEnabled: settings?.hapticsEnabled ?? DEFAULT_SETTINGS.hapticsEnabled,
+		hidePromptExamples: settings?.hidePromptExamples ?? DEFAULT_SETTINGS.hidePromptExamples,
+		shareConversationsWithModelAuthors:
+			settings?.shareConversationsWithModelAuthors ??
+			DEFAULT_SETTINGS.shareConversationsWithModelAuthors,
+
+		customPrompts: settings?.customPrompts ?? {},
+		multimodalOverrides: settings?.multimodalOverrides ?? {},
+		toolsOverrides: settings?.toolsOverrides ?? {},
+		providerOverrides: settings?.providerOverrides ?? {},
+		autopilotEnabled: settings?.autopilotEnabled ?? DEFAULT_SETTINGS.autopilotEnabled,
+		billingOrganization: settings?.billingOrganization ?? undefined,
+	});
+};
+
+export const POST: RequestHandler = async ({ locals, request }) => {
+	requireAuth(locals);
+	const body = await request.json();
+
+	const { welcomeModalSeen, ...parsedSettings } = settingsSchema.parse(body);
+	const streamingMode = resolveStreamingMode(parsedSettings);
+
+	const settings = {
+		...parsedSettings,
+		streamingMode,
+	} satisfies SettingsEditable;
+
+	await collections.settings.updateOne(
+		authCondition(locals),
+		{
+			$set: {
+				...settings,
+				...(welcomeModalSeen && { welcomeModalSeenAt: new Date() }),
+				updatedAt: new Date(),
+			},
+			$setOnInsert: {
+				createdAt: new Date(),
+			},
+		},
+		{ upsert: true }
+	);
+
+	return new Response();
+};