ruflo 3.5.2 → 3.5.4

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

@@ -0,0 +1,13 @@
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+
+export function findRepoRoot(startPath: string): string {
+	let currentPath = startPath;
+	while (currentPath !== "/") {
+		if (existsSync(join(currentPath, "package.json"))) {
+			return currentPath;
+		}
+		currentPath = dirname(currentPath);
+	}
+	throw new Error("Could not find repository root (no package.json found)");
+}

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

@@ -0,0 +1,46 @@
+import { taskModel, models } from "$lib/server/models";
+import { MessageUpdateType, type MessageUpdate } from "$lib/types/MessageUpdate";
+import type { EndpointMessage } from "./endpoints/endpoints";
+
+export async function* generateFromDefaultEndpoint({
+	messages,
+	preprompt,
+	generateSettings,
+	modelId,
+	locals,
+}: {
+	messages: EndpointMessage[];
+	preprompt?: string;
+	generateSettings?: Record<string, unknown>;
+	/** Optional: use this model instead of the default task model */
+	modelId?: string;
+	locals: App.Locals | undefined;
+}): AsyncGenerator<MessageUpdate, string, undefined> {
+	try {
+		// Choose endpoint based on provided modelId, else fall back to taskModel
+		const model = modelId ? (models.find((m) => m.id === modelId) ?? taskModel) : taskModel;
+		const endpoint = await model.getEndpoint();
+		const tokenStream = await endpoint({ messages, preprompt, generateSettings, locals });
+
+		for await (const output of tokenStream) {
+			// if not generated_text is here it means the generation is not done
+			if (output.generated_text) {
+				let generated_text = output.generated_text;
+				for (const stop of [...(model.parameters?.stop ?? []), "<|endoftext|>"]) {
+					if (generated_text.endsWith(stop)) {
+						generated_text = generated_text.slice(0, -stop.length).trimEnd();
+					}
+				}
+				return generated_text;
+			}
+			yield {
+				type: MessageUpdateType.Stream,
+				token: output.token.text,
+			};
+		}
+	} catch (error) {
+		return "";
+	}
+
+	return "";
+}

package/src/ruvocal/src/lib/server/hooks/error.ts

@@ -0,0 +1,37 @@
+import type { HandleServerError } from "@sveltejs/kit";
+import { logger } from "$lib/server/logger";
+
+type HandleServerErrorInput = Parameters<HandleServerError>[0];
+
+export async function handleServerError({
+	error,
+	event,
+	status,
+	message,
+}: HandleServerErrorInput): Promise<App.Error> {
+	// handle 404
+	if (event.route.id === null) {
+		return {
+			message: `Page ${event.url.pathname} not found`,
+		};
+	}
+
+	const errorId = crypto.randomUUID();
+
+	logger.error({
+		locals: event.locals,
+		url: event.request.url,
+		params: event.params,
+		request: event.request,
+		message,
+		error,
+		errorId,
+		status,
+		stack: error instanceof Error ? error.stack : undefined,
+	});
+
+	return {
+		message: "An error occurred",
+		errorId,
+	};
+}

package/src/ruvocal/src/lib/server/hooks/fetch.ts

@@ -0,0 +1,22 @@
+import type { HandleFetch } from "@sveltejs/kit";
+import { isHostLocalhost } from "$lib/server/isURLLocal";
+
+type HandleFetchInput = Parameters<HandleFetch>[0];
+
+export async function handleFetchRequest({
+	event,
+	request,
+	fetch,
+}: HandleFetchInput): Promise<Response> {
+	if (isHostLocalhost(new URL(request.url).hostname)) {
+		const cookieHeader = event.request.headers.get("cookie");
+		if (cookieHeader) {
+			const headers = new Headers(request.headers);
+			headers.set("cookie", cookieHeader);
+
+			return fetch(new Request(request, { headers }));
+		}
+	}
+
+	return fetch(request);
+}

package/src/ruvocal/src/lib/server/hooks/handle.ts

@@ -0,0 +1,250 @@
+import type { Handle, RequestEvent } from "@sveltejs/kit";
+import { collections } from "$lib/server/database";
+import { base } from "$app/paths";
+import { dev } from "$app/environment";
+import {
+	authenticateRequest,
+	loginEnabled,
+	refreshSessionCookie,
+	triggerOauthFlow,
+} from "$lib/server/auth";
+import { ERROR_MESSAGES } from "$lib/stores/errors";
+import { addWeeks } from "date-fns";
+import { logger } from "$lib/server/logger";
+import { adminTokenManager } from "$lib/server/adminToken";
+import { isHostLocalhost } from "$lib/server/isURLLocal";
+import { runWithRequestContext, updateRequestContext } from "$lib/server/requestContext";
+import { config, ready } from "$lib/server/config";
+
+type HandleInput = Parameters<Handle>[0];
+
+function getClientAddressSafe(event: RequestEvent): string | undefined {
+	try {
+		return event.getClientAddress();
+	} catch {
+		return undefined;
+	}
+}
+
+export async function handleRequest({ event, resolve }: HandleInput): Promise<Response> {
+	// Generate a unique request ID for this request
+	const requestId = crypto.randomUUID();
+
+	// Run the entire request handling within the request context
+	return runWithRequestContext(
+		async () => {
+			await ready.then(() => {
+				config.checkForUpdates();
+			});
+
+			logger.debug(
+				{
+					locals: event.locals,
+					url: event.url.pathname,
+					params: event.params,
+					request: event.request,
+				},
+				"Request received"
+			);
+
+			function errorResponse(status: number, message: string) {
+				const sendJson =
+					event.request.headers.get("accept")?.includes("application/json") ||
+					event.request.headers.get("content-type")?.includes("application/json");
+				return new Response(sendJson ? JSON.stringify({ error: message }) : message, {
+					status,
+					headers: {
+						"content-type": sendJson ? "application/json" : "text/plain",
+					},
+				});
+			}
+
+			if (
+				event.url.pathname.startsWith(`${base}/admin/`) ||
+				event.url.pathname === `${base}/admin`
+			) {
+				const ADMIN_SECRET = config.ADMIN_API_SECRET || config.PARQUET_EXPORT_SECRET;
+
+				if (!ADMIN_SECRET) {
+					return errorResponse(500, "Admin API is not configured");
+				}
+
+				if (event.request.headers.get("Authorization") !== `Bearer ${ADMIN_SECRET}`) {
+					return errorResponse(401, "Unauthorized");
+				}
+			}
+
+			const isApi = event.url.pathname.startsWith(`${base}/api/`);
+			const auth = await authenticateRequest(
+				event.request.headers,
+				event.cookies,
+				event.url,
+				isApi
+			);
+
+			event.locals.sessionId = auth.sessionId;
+
+			if (loginEnabled && !auth.user && !event.url.pathname.startsWith(`${base}/.well-known/`)) {
+				if (config.AUTOMATIC_LOGIN === "true") {
+					// AUTOMATIC_LOGIN: always redirect to OAuth flow (unless already on login or healthcheck pages)
+					if (
+						!event.url.pathname.startsWith(`${base}/login`) &&
+						!event.url.pathname.startsWith(`${base}/healthcheck`)
+					) {
+						// To get the same CSRF token after callback
+						refreshSessionCookie(event.cookies, auth.secretSessionId);
+						return await triggerOauthFlow(event);
+					}
+				} else {
+					// Redirect to OAuth flow unless on the authorized pages (home, shared conversation, login, healthcheck, model thumbnails)
+					if (
+						event.url.pathname !== `${base}/` &&
+						event.url.pathname !== `${base}` &&
+						!event.url.pathname.startsWith(`${base}/login`) &&
+						!event.url.pathname.startsWith(`${base}/login/callback`) &&
+						!event.url.pathname.startsWith(`${base}/healthcheck`) &&
+						!event.url.pathname.startsWith(`${base}/r/`) &&
+						!event.url.pathname.startsWith(`${base}/conversation/`) &&
+						!event.url.pathname.startsWith(`${base}/models/`) &&
+						!event.url.pathname.startsWith(`${base}/api`)
+					) {
+						refreshSessionCookie(event.cookies, auth.secretSessionId);
+						return triggerOauthFlow(event);
+					}
+				}
+			}
+
+			event.locals.user = auth.user || undefined;
+			event.locals.token = auth.token;
+
+			// Update request context with user after authentication
+			if (auth.user?.username) {
+				updateRequestContext({ user: auth.user.username });
+			}
+
+			event.locals.isAdmin =
+				event.locals.user?.isAdmin || adminTokenManager.isAdmin(event.locals.sessionId);
+
+			// CSRF protection
+			const requestContentType = event.request.headers.get("content-type")?.split(";")[0] ?? "";
+			/** https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form#attr-enctype */
+			const nativeFormContentTypes = [
+				"multipart/form-data",
+				"application/x-www-form-urlencoded",
+				"text/plain",
+			];
+
+			if (event.request.method === "POST") {
+				if (nativeFormContentTypes.includes(requestContentType)) {
+					const origin = event.request.headers.get("origin");
+
+					if (!origin) {
+						return errorResponse(403, "Non-JSON form requests need to have an origin");
+					}
+
+					const validOrigins = [
+						new URL(event.request.url).host,
+						...(config.PUBLIC_ORIGIN ? [new URL(config.PUBLIC_ORIGIN).host] : []),
+					];
+
+					if (!validOrigins.includes(new URL(origin).host)) {
+						return errorResponse(403, "Invalid referer for POST request");
+					}
+				}
+			}
+
+			if (
+				event.request.method === "POST" ||
+				event.url.pathname.startsWith(`${base}/login`) ||
+				event.url.pathname.startsWith(`${base}/login/callback`)
+			) {
+				// if the request is a POST request or login-related we refresh the cookie
+				refreshSessionCookie(event.cookies, auth.secretSessionId);
+
+				await collections.sessions.updateOne(
+					{ sessionId: auth.sessionId },
+					{ $set: { updatedAt: new Date(), expiresAt: addWeeks(new Date(), 2) } }
+				);
+			}
+
+			if (
+				loginEnabled &&
+				!event.locals.user &&
+				!event.url.pathname.startsWith(`${base}/login`) &&
+				!event.url.pathname.startsWith(`${base}/admin`) &&
+				!event.url.pathname.startsWith(`${base}/settings`) &&
+				!["GET", "OPTIONS", "HEAD"].includes(event.request.method)
+			) {
+				return errorResponse(401, ERROR_MESSAGES.authOnly);
+			}
+
+			let replaced = false;
+
+			const response = await resolve(event, {
+				transformPageChunk: (chunk) => {
+					// For some reason, Sveltekit doesn't let us load env variables from .env in the app.html template
+					if (replaced || !chunk.html.includes("%gaId%")) {
+						return chunk.html;
+					}
+					replaced = true;
+
+					return chunk.html.replace("%gaId%", config.PUBLIC_GOOGLE_ANALYTICS_ID);
+				},
+				filterSerializedResponseHeaders: (header) => {
+					return header.includes("content-type");
+				},
+			});
+
+			// Update request context with status code
+			updateRequestContext({ statusCode: response.status });
+
+			// Add CSP header to control iframe embedding
+			// Always allow huggingface.co; when ALLOW_IFRAME=true, allow all domains
+			if (config.ALLOW_IFRAME !== "true") {
+				response.headers.append(
+					"Content-Security-Policy",
+					"frame-ancestors https://huggingface.co;"
+				);
+			}
+
+			if (
+				event.url.pathname.startsWith(`${base}/login/callback`) ||
+				event.url.pathname.startsWith(`${base}/login`)
+			) {
+				response.headers.append("Cache-Control", "no-store");
+			}
+
+			if (event.url.pathname.startsWith(`${base}/api/`)) {
+				// get origin from the request
+				const requestOrigin = event.request.headers.get("origin");
+
+				// get origin from the config if its defined
+				let allowedOrigin = config.PUBLIC_ORIGIN ? new URL(config.PUBLIC_ORIGIN).origin : undefined;
+
+				if (
+					dev || // if we're in dev mode
+					!requestOrigin || // or the origin is null (SSR)
+					isHostLocalhost(new URL(requestOrigin).hostname) // or the origin is localhost
+				) {
+					allowedOrigin = "*"; // allow all origins
+				} else if (allowedOrigin === requestOrigin) {
+					allowedOrigin = requestOrigin; // echo back the caller
+				}
+
+				if (allowedOrigin) {
+					response.headers.set("Access-Control-Allow-Origin", allowedOrigin);
+					response.headers.set(
+						"Access-Control-Allow-Methods",
+						"GET, POST, PUT, PATCH, DELETE, OPTIONS"
+					);
+					response.headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization");
+				}
+			}
+
+			logger.info("Request completed");
+
+			return response;
+		},
+		{ requestId, url: event.url.pathname, ip: getClientAddressSafe(event) }
+	);
+}

package/src/ruvocal/src/lib/server/hooks/init.ts

@@ -0,0 +1,51 @@
+import { config, ready } from "$lib/server/config";
+import { logger } from "$lib/server/logger";
+import { initExitHandler } from "$lib/server/exitHandler";
+import { checkAndRunMigrations } from "$lib/migrations/migrations";
+import { refreshConversationStats } from "$lib/jobs/refresh-conversation-stats";
+import { loadMcpServersOnStartup } from "$lib/server/mcp/registry";
+import { AbortedGenerations } from "$lib/server/abortedGenerations";
+import { adminTokenManager } from "$lib/server/adminToken";
+import { MetricsServer } from "$lib/server/metrics";
+
+export async function initServer(): Promise<void> {
+	// Wait for config to be fully loaded
+	await ready;
+
+	// Ensure legacy env expected by some libs: map OPENAI_API_KEY -> HF_TOKEN if absent
+	const canonicalToken = config.OPENAI_API_KEY || config.HF_TOKEN;
+	if (canonicalToken) {
+		process.env.HF_TOKEN ??= canonicalToken;
+	}
+
+	// Warn if legacy-only var is used
+	if (!config.OPENAI_API_KEY && config.HF_TOKEN) {
+		logger.warn(
+			"HF_TOKEN is deprecated in favor of OPENAI_API_KEY. Please migrate to OPENAI_API_KEY."
+		);
+	}
+
+	logger.info("Starting server...");
+	initExitHandler();
+
+	if (config.METRICS_ENABLED === "true") {
+		MetricsServer.getInstance();
+	}
+
+	checkAndRunMigrations();
+	refreshConversationStats();
+
+	// Load MCP servers at startup
+	loadMcpServersOnStartup();
+
+	// Init AbortedGenerations refresh process
+	AbortedGenerations.getInstance();
+
+	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."
+		);
+	}
+}

package/src/ruvocal/src/lib/server/isURLLocal.spec.ts

@@ -0,0 +1,31 @@
+import { isURLLocal } from "./isURLLocal";
+import { describe, expect, it } from "vitest";
+
+describe("isURLLocal", async () => {
+	it("should return true for localhost", async () => {
+		expect(await isURLLocal(new URL("http://localhost"))).toBe(true);
+	});
+	it("should return true for 127.0.0.1", async () => {
+		expect(await isURLLocal(new URL("http://127.0.0.1"))).toBe(true);
+	});
+	it("should return true for 127.254.254.254", async () => {
+		expect(await isURLLocal(new URL("http://127.254.254.254"))).toBe(true);
+	});
+	it("should return false for huggingface.co", async () => {
+		expect(await isURLLocal(new URL("https://huggingface.co/"))).toBe(false);
+	});
+	it("should return true for 127.0.0.1.nip.io", async () => {
+		expect(await isURLLocal(new URL("http://127.0.0.1.nip.io"))).toBe(true);
+	});
+	it("should fail on ipv6", async () => {
+		await expect(isURLLocal(new URL("http://[::1]"))).rejects.toThrow();
+	});
+	it("should fail on ipv6 --1.sslip.io", async () => {
+		await expect(isURLLocal(new URL("http://--1.sslip.io"))).rejects.toThrow();
+	});
+	it("should fail on invalid domain names", async () => {
+		await expect(
+			isURLLocal(new URL("http://34329487239847329874923948732984.com/"))
+		).rejects.toThrow();
+	});
+});

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

@@ -0,0 +1,74 @@
+import { Address6, Address4 } from "ip-address";
+import dns from "node:dns";
+import { isIP } from "node:net";
+
+const dnsLookup = (hostname: string): Promise<{ address: string; family: number }> => {
+	return new Promise((resolve, reject) => {
+		dns.lookup(hostname, (err, address, family) => {
+			if (err) return reject(err);
+			resolve({ address, family });
+		});
+	});
+};
+
+function assertValidHostname(hostname: string): void {
+	if (!hostname || hostname.length > 253) {
+		throw new Error("Invalid hostname");
+	}
+
+	const labels = hostname.split(".");
+
+	for (const label of labels) {
+		if (!label || label.length > 63) {
+			throw new Error("Invalid hostname");
+		}
+
+		if (!/^[A-Za-z0-9-]+$/.test(label)) {
+			throw new Error("Invalid hostname");
+		}
+
+		if (label.startsWith("-") || label.endsWith("-")) {
+			throw new Error("Invalid hostname");
+		}
+	}
+}
+
+export async function isURLLocal(URL: URL): Promise<boolean> {
+	if (!isIP(URL.hostname)) {
+		assertValidHostname(URL.hostname);
+	}
+
+	const { address, family } = await dnsLookup(URL.hostname);
+
+	if (family === 4) {
+		const addr = new Address4(address);
+		const localSubnet = new Address4("127.0.0.0/8");
+		return addr.isInSubnet(localSubnet);
+	}
+
+	if (family === 6) {
+		const addr = new Address6(address);
+		return addr.isLoopback() || addr.isInSubnet(new Address6("::1/128")) || addr.isLinkLocal();
+	}
+
+	throw Error("Unknown IP family");
+}
+
+export function isURLStringLocal(url: string) {
+	try {
+		const urlObj = new URL(url);
+		return isURLLocal(urlObj);
+	} catch (e) {
+		// assume local if URL parsing fails
+		return true;
+	}
+}
+
+export function isHostLocalhost(host: string): boolean {
+	if (host === "localhost") return true;
+	if (host === "::1" || host === "[::1]") return true;
+	if (host.startsWith("127.") && isIP(host)) return true;
+	if (host.endsWith(".localhost")) return true;
+
+	return false;
+}

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

@@ -0,0 +1,42 @@
+import pino from "pino";
+import { dev } from "$app/environment";
+import { config } from "$lib/server/config";
+import { getRequestContext } from "$lib/server/requestContext";
+
+let options: pino.LoggerOptions = {};
+
+if (dev) {
+	options = {
+		transport: {
+			target: "pino-pretty",
+			options: {
+				colorize: true,
+			},
+		},
+	};
+}
+
+const baseLogger = pino({
+	...options,
+	messageKey: "message",
+	level: config.LOG_LEVEL || "info",
+	formatters: {
+		level: (label) => {
+			return { level: label };
+		},
+	},
+	mixin() {
+		const ctx = getRequestContext();
+		if (!ctx) return {};
+
+		const result: Record<string, string | number> = {};
+		if (ctx.requestId) result.request_id = ctx.requestId;
+		if (ctx.url) result.url = ctx.url;
+		if (ctx.ip) result.ip = ctx.ip;
+		if (ctx.user) result.user = ctx.user;
+		if (ctx.statusCode) result.status_code = ctx.statusCode;
+		return result;
+	},
+});
+
+export const logger = baseLogger;

package/src/ruvocal/src/lib/server/mcp/clientPool.ts

@@ -0,0 +1,70 @@
+import { Client } from "@modelcontextprotocol/sdk/client";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import type { McpServerConfig } from "./httpClient";
+
+const pool = new Map<string, Client>();
+
+function keyOf(server: McpServerConfig) {
+	const headers = Object.entries(server.headers ?? {})
+		.sort(([a], [b]) => a.localeCompare(b))
+		.map(([k, v]) => `${k}:${v}`)
+		.join("|\u0000|");
+	return `${server.url}|${headers}`;
+}
+
+export async function getClient(server: McpServerConfig, signal?: AbortSignal): Promise<Client> {
+	const key = keyOf(server);
+	const existing = pool.get(key);
+	if (existing) return existing;
+
+	let firstError: unknown;
+	const client = new Client({ name: "chat-ui-mcp", version: "0.1.0" });
+	const url = new URL(server.url);
+	const requestInit: RequestInit = { headers: server.headers, signal };
+	try {
+		try {
+			await client.connect(new StreamableHTTPClientTransport(url, { requestInit }));
+		} catch (httpErr) {
+			// Remember the original HTTP transport error so we can surface it if the fallback also fails.
+			// Today we always show the SSE message, which is misleading when the real failure was HTTP (e.g. 500).
+			firstError = httpErr;
+			await client.connect(new SSEClientTransport(url, { requestInit }));
+		}
+	} catch (err) {
+		try {
+			await client.close?.();
+		} catch {}
+		// Prefer the HTTP error if both transports fail; otherwise fall back to the last error.
+		if (firstError) {
+			const message =
+				"HTTP transport failed: " +
+				String(firstError instanceof Error ? firstError.message : firstError) +
+				"; SSE fallback failed: " +
+				String(err instanceof Error ? err.message : err);
+			throw new Error(message, { cause: err instanceof Error ? err : undefined });
+		}
+		throw err;
+	}
+
+	pool.set(key, client);
+	return client;
+}
+
+export async function drainPool() {
+	for (const [key, client] of pool) {
+		try {
+			await client.close?.();
+		} catch {}
+		pool.delete(key);
+	}
+}
+
+export function evictFromPool(server: McpServerConfig): Client | undefined {
+	const key = keyOf(server);
+	const client = pool.get(key);
+	if (client) {
+		pool.delete(key);
+	}
+	return client;
+}