ruflo 3.5.2 → 3.5.3

package/src/ruvocal/scripts/populate.ts

@@ -0,0 +1,288 @@
+import readline from "readline";
+import minimist from "minimist";
+
+// @ts-expect-error: vite-node makes the var available but the typescript compiler doesn't see them
+import { env } from "$env/dynamic/private";
+
+import { faker } from "@faker-js/faker";
+import { ObjectId } from "mongodb";
+
+// @ts-expect-error: vite-node makes the var available but the typescript compiler doesn't see them
+import { ready } from "$lib/server/config";
+import { collections } from "$lib/server/database.ts";
+import { models } from "../src/lib/server/models.ts";
+import type { User } from "../src/lib/types/User";
+import type { Assistant } from "../src/lib/types/Assistant";
+import type { Conversation } from "../src/lib/types/Conversation";
+import type { Settings } from "../src/lib/types/Settings";
+import { Message } from "../src/lib/types/Message.ts";
+
+import { addChildren } from "../src/lib/utils/tree/addChildren.ts";
+import { generateSearchTokens } from "../src/lib/utils/searchTokens.ts";
+import { ReviewStatus } from "../src/lib/types/Review.ts";
+import fs from "fs";
+import path from "path";
+
+const rl = readline.createInterface({
+	input: process.stdin,
+	output: process.stdout,
+});
+
+await ready;
+
+rl.on("close", function () {
+	process.exit(0);
+});
+
+const samples = fs.readFileSync(path.join(__dirname, "samples.txt"), "utf8").split("\n---\n");
+
+const possibleFlags = ["reset", "all", "users", "settings", "assistants", "conversations"];
+const argv = minimist(process.argv.slice(2));
+const flags = argv["_"].filter((flag) => possibleFlags.includes(flag));
+
+async function generateMessages(preprompt?: string): Promise<Message[]> {
+	const isLinear = faker.datatype.boolean(0.5);
+	const isInterrupted = faker.datatype.boolean(0.05);
+
+	const messages: Message[] = [];
+
+	messages.push({
+		id: crypto.randomUUID(),
+		from: "system",
+		content: preprompt ?? "",
+		createdAt: faker.date.recent({ days: 30 }),
+		updatedAt: faker.date.recent({ days: 30 }),
+	});
+
+	let isUser = true;
+	let lastId = messages[0].id;
+	if (isLinear) {
+		const convLength = faker.number.int({ min: 1, max: 25 }) * 2; // must always be even
+
+		for (let i = 0; i < convLength; i++) {
+			lastId = addChildren(
+				{
+					messages,
+					rootMessageId: messages[0].id,
+				},
+				{
+					from: isUser ? "user" : "assistant",
+					content:
+						faker.lorem.sentence({
+							min: 10,
+							max: isUser ? 50 : 200,
+						}) +
+						(!isUser && Math.random() < 0.1
+							? "\n```\n" + faker.helpers.arrayElement(samples) + "\n```\n"
+							: ""),
+					createdAt: faker.date.recent({ days: 30 }),
+					updatedAt: faker.date.recent({ days: 30 }),
+					interrupted: !isUser && i === convLength - 1 && isInterrupted,
+				},
+				lastId
+			);
+			isUser = !isUser;
+		}
+	} else {
+		const convLength = faker.number.int({ min: 2, max: 200 });
+
+		for (let i = 0; i < convLength; i++) {
+			addChildren(
+				{
+					messages,
+					rootMessageId: messages[0].id,
+				},
+				{
+					from: isUser ? "user" : "assistant",
+					content:
+						faker.lorem.sentence({
+							min: 10,
+							max: isUser ? 50 : 200,
+						}) +
+						(!isUser && Math.random() < 0.1
+							? "\n```\n" + faker.helpers.arrayElement(samples) + "\n```\n"
+							: ""),
+					createdAt: faker.date.recent({ days: 30 }),
+					updatedAt: faker.date.recent({ days: 30 }),
+					interrupted: !isUser && i === convLength - 1 && isInterrupted,
+				},
+				faker.helpers.arrayElement([
+					messages[0].id,
+					...messages.filter((m) => m.from === (isUser ? "assistant" : "user")).map((m) => m.id),
+				])
+			);
+
+			isUser = !isUser;
+		}
+	}
+	return messages;
+}
+
+async function seed() {
+	console.log("Seeding...");
+	const modelIds = models.map((model) => model.id);
+
+	if (flags.includes("reset")) {
+		console.log("Starting reset of DB");
+		await collections.users.deleteMany({});
+		await collections.settings.deleteMany({});
+		await collections.assistants.deleteMany({});
+		await collections.conversations.deleteMany({});
+		await collections.migrationResults.deleteMany({});
+		await collections.semaphores.deleteMany({});
+		console.log("Reset done");
+	}
+
+	if (flags.includes("users") || flags.includes("all")) {
+		console.log("Creating 100 new users");
+		const newUsers: User[] = Array.from({ length: 100 }, () => ({
+			_id: new ObjectId(),
+			createdAt: faker.date.recent({ days: 30 }),
+			updatedAt: faker.date.recent({ days: 30 }),
+			username: faker.internet.userName(),
+			name: faker.person.fullName(),
+			hfUserId: faker.string.alphanumeric(24),
+			avatarUrl: faker.image.avatar(),
+		}));
+
+		await collections.users.insertMany(newUsers);
+		console.log("Done creating users.");
+	}
+
+	const users = await collections.users.find().toArray();
+	if (flags.includes("settings") || flags.includes("all")) {
+		console.log("Updating settings for all users");
+		users.forEach(async (user) => {
+			const settings: Settings = {
+				userId: user._id,
+				shareConversationsWithModelAuthors: faker.datatype.boolean(0.25),
+				hideEmojiOnSidebar: faker.datatype.boolean(0.25),
+				activeModel: faker.helpers.arrayElement(modelIds),
+				createdAt: faker.date.recent({ days: 30 }),
+				updatedAt: faker.date.recent({ days: 30 }),
+				disableStream: faker.datatype.boolean(0.25),
+				directPaste: faker.datatype.boolean(0.25),
+				hidePromptExamples: {},
+				customPrompts: {},
+				assistants: [],
+			};
+			await collections.settings.updateOne(
+				{ userId: user._id },
+				{ $set: { ...settings } },
+				{ upsert: true }
+			);
+		});
+		console.log("Done updating settings.");
+	}
+
+	if (flags.includes("assistants") || flags.includes("all")) {
+		console.log("Creating assistants for all users");
+		await Promise.all(
+			users.map(async (user) => {
+				const name = faker.animal.insect();
+				const assistants = faker.helpers.multiple<Assistant>(
+					() => ({
+						_id: new ObjectId(),
+						name,
+						createdById: user._id,
+						createdByName: user.username,
+						createdAt: faker.date.recent({ days: 30 }),
+						updatedAt: faker.date.recent({ days: 30 }),
+						userCount: faker.number.int({ min: 1, max: 100000 }),
+						review: faker.helpers.enumValue(ReviewStatus),
+						modelId: faker.helpers.arrayElement(modelIds),
+						description: faker.lorem.sentence(),
+						preprompt: faker.hacker.phrase(),
+						exampleInputs: faker.helpers.multiple(() => faker.lorem.sentence(), {
+							count: faker.number.int({ min: 0, max: 4 }),
+						}),
+						searchTokens: generateSearchTokens(name),
+						last24HoursCount: faker.number.int({ min: 0, max: 1000 }),
+					}),
+					{ count: faker.number.int({ min: 3, max: 10 }) }
+				);
+				await collections.assistants.insertMany(assistants);
+				await collections.settings.updateOne(
+					{ userId: user._id },
+					{ $set: { assistants: assistants.map((a) => a._id.toString()) } },
+					{ upsert: true }
+				);
+			})
+		);
+		console.log("Done creating assistants.");
+	}
+
+	if (flags.includes("conversations") || flags.includes("all")) {
+		console.log("Creating conversations for all users");
+		await Promise.all(
+			users.map(async (user) => {
+				const conversations = faker.helpers.multiple(
+					async () => {
+						const settings = await collections.settings.findOne<Settings>({ userId: user._id });
+
+						const assistantId =
+							settings?.assistants && settings.assistants.length > 0 && faker.datatype.boolean(0.1)
+								? faker.helpers.arrayElement<ObjectId>(settings.assistants)
+								: undefined;
+
+						const preprompt =
+							(assistantId
+								? await collections.assistants
+										.findOne({ _id: assistantId })
+										.then((assistant: Assistant) => assistant?.preprompt ?? "")
+								: faker.helpers.maybe(() => faker.hacker.phrase(), { probability: 0.5 })) ?? "";
+
+						const messages = await generateMessages(preprompt);
+
+						const conv = {
+							_id: new ObjectId(),
+							userId: user._id,
+							assistantId,
+							preprompt,
+							createdAt: faker.date.recent({ days: 145 }),
+							updatedAt: faker.date.recent({ days: 145 }),
+							model: faker.helpers.arrayElement(modelIds),
+							title: faker.internet.emoji() + " " + faker.hacker.phrase(),
+							// embeddings removed in this build
+							messages,
+							rootMessageId: messages[0].id,
+						} satisfies Conversation;
+
+						return conv;
+					},
+					{ count: faker.number.int({ min: 10, max: 200 }) }
+				);
+
+				await collections.conversations.insertMany(await Promise.all(conversations));
+			})
+		);
+		console.log("Done creating conversations.");
+	}
+}
+
+// run seed
+(async () => {
+	try {
+		rl.question(
+			"You're about to run a seeding script on the following MONGODB_URL: \x1b[31m" +
+				env.MONGODB_URL +
+				"\x1b[0m\n\n With the following flags: \x1b[31m" +
+				flags.join("\x1b[0m , \x1b[31m") +
+				"\x1b[0m\n \n\n Are you sure you want to continue? (yes/no): ",
+			async (confirm) => {
+				if (confirm !== "yes") {
+					console.log("Not 'yes', exiting.");
+					rl.close();
+					process.exit(0);
+				}
+				console.log("Starting seeding...");
+				await seed();
+				console.log("Seeding done.");
+				rl.close();
+			}
+		);
+	} catch (e) {
+		console.error(e);
+		process.exit(1);
+	}
+})();

package/src/ruvocal/scripts/samples.txt

@@ -0,0 +1,194 @@
+import { Observable, of, from, interval, throwError } from 'rxjs';
+import { map, filter, catchError, switchMap, take, tap } from 'rxjs/operators';
+
+// Mock function to fetch stock prices (simulates API call)
+const fetchStockPrice = (ticker: string): Observable<number> => {
+    return new Observable<number>((observer) => {
+        const intervalId = setInterval(() => {
+            if (Math.random() < 0.1) { // Simulating an error 10% of the time
+                observer.error(`Error fetching stock price for ${ticker}`);
+            } else {
+                const price = parseFloat((Math.random() * 1000).toFixed(2));
+                observer.next(price);
+            }
+        }, 1000);
+
+        return () => {
+            clearInterval(intervalId);
+            console.log(`Stopped fetching prices for ${ticker}`);
+        };
+    });
+};
+
+// Example usage: Tracking stock price updates
+const stockTicker = 'AAPL';
+const stockPrice$ = fetchStockPrice(stockTicker).pipe(
+    map(price => ({ ticker: stockTicker, price })),  // Transform data
+    filter(data => data.price > 500), // Only keep prices above 500
+    tap(data => console.log(`Price update:`, data)), // Side effect: Logging
+    catchError(err => {
+        console.error(err);
+        return of({ ticker: stockTicker, price: null }); // Fallback observable
+    })
+);
+
+// Subscribe to the stock price updates
+const subscription = stockPrice$.subscribe({
+    next: data => console.log(`Subscriber received:`, data),
+    error: err => console.error(`Subscription error:`, err),
+    complete: () => console.log('Stream complete'),
+});
+
+// Automatically unsubscribe after 10 seconds
+setTimeout(() => {
+    subscription.unsubscribe();
+    console.log('Unsubscribed from stock price updates.');
+}, 10000);
+---
+class EnforceAttrsMeta(type):
+    """
+    Metaclass that enforces the presence of specific attributes in a class
+    and automatically decorates methods with a logging wrapper.
+    """
+    
+    required_attributes = ['name', 'version']
+
+    def __new__(cls, name, bases, class_dict):
+        """
+        Create a new class with enforced attributes and method logging.
+
+        :param name: Name of the class being created.
+        :param bases: Tuple of base classes.
+        :param class_dict: Dictionary of attributes and methods of the class.
+        :return: Newly created class object.
+        """
+        # Ensure required attributes exist
+        for attr in cls.required_attributes:
+            if attr not in class_dict:
+                raise TypeError(f"Class '{name}' is missing required attribute '{attr}'")
+
+        # Wrap all methods in a logging decorator
+        for key, value in class_dict.items():
+            if callable(value):  # Check if it's a method
+                class_dict[key] = cls.log_calls(value)
+
+        return super().__new__(cls, name, bases, class_dict)
+
+    @staticmethod
+    def log_calls(func):
+        """
+        Decorator that logs method calls and arguments.
+
+        :param func: Function to be wrapped.
+        :return: Wrapped function with logging.
+        """
+        def wrapper(*args, **kwargs):
+            print(f"Calling {func.__name__} with args={args} kwargs={kwargs}")
+            result = func(*args, **kwargs)
+            print(f"{func.__name__} returned {result}")
+            return result
+        return wrapper
+
+
+class PluginBase(metaclass=EnforceAttrsMeta):
+    """
+    Base class for plugins that enforces required attributes and logging.
+    """
+    name = "BasePlugin"
+    version = "1.0"
+
+    def run(self, data):
+        """
+        Process the input data.
+
+        :param data: The data to be processed.
+        :return: Processed result.
+        """
+        return f"Processed {data}"
+
+
+class CustomPlugin(PluginBase):
+    """
+    Custom plugin that extends PluginBase and adheres to enforced rules.
+    """
+    name = "CustomPlugin"
+    version = "2.0"
+
+    def run(self, data):
+        """
+        Custom processing logic.
+
+        :param data: The data to process.
+        :return: Modified data.
+        """
+        return f"Custom processing of {data}"
+
+
+# Uncommenting the following class definition will raise a TypeError
+# because 'version' attribute is missing.
+# class InvalidPlugin(PluginBase):
+#     name = "InvalidPlugin"
+
+
+if __name__ == "__main__":
+    # Instantiate and use the plugin
+    plugin = CustomPlugin()
+    print(plugin.run("example data"))
+---
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Click the Box Game</title>
+    <style>
+        body {
+            text-align: center;
+            font-family: Arial, sans-serif;
+        }
+        #game-container {
+            position: relative;
+            width: 300px;
+            height: 300px;
+            margin: 20px auto;
+            border: 2px solid black;
+            overflow: hidden;
+        }
+        #target {
+            width: 50px;
+            height: 50px;
+            background-color: red;
+            position: absolute;
+            cursor: pointer;
+        }
+    </style>
+</head>
+<body>
+    <h1>Click the Box!</h1>
+    <p>Score: <span id="score">0</span></p>
+    <div id="game-container">
+        <div id="target"></div>
+    </div>
+    <script>
+        let score = 0;
+        const target = document.getElementById("target");
+        const scoreDisplay = document.getElementById("score");
+        const container = document.getElementById("game-container");
+        
+        function moveTarget() {
+            const maxX = container.clientWidth - target.clientWidth;
+            const maxY = container.clientHeight - target.clientHeight;
+            target.style.left = Math.random() * maxX + "px";
+            target.style.top = Math.random() * maxY + "px";
+        }
+        
+        target.addEventListener("click", function() {
+            score++;
+            scoreDisplay.textContent = score;
+            moveTarget();
+        });
+        
+        moveTarget();
+    </script>
+</body>
+</html>

package/src/ruvocal/scripts/setups/vitest-setup-server.ts

@@ -0,0 +1,44 @@
+import { vi, afterAll } from "vitest";
+import dotenv from "dotenv";
+import { resolve } from "path";
+import fs from "fs";
+
+// Load the .env file
+const envPath = resolve(__dirname, "../../.env");
+dotenv.config({ path: envPath });
+
+// Read the .env file content
+const envContent = fs.readFileSync(envPath, "utf-8");
+
+// Parse the .env content
+const envVars = dotenv.parse(envContent);
+
+// Separate public and private variables
+const publicEnv = {};
+const privateEnv = {};
+
+for (const [key, value] of Object.entries(envVars)) {
+	if (key.startsWith("PUBLIC_")) {
+		publicEnv[key] = value;
+	} else {
+		privateEnv[key] = value;
+	}
+}
+
+vi.mock("$env/dynamic/public", () => ({
+	env: publicEnv,
+}));
+
+vi.mock("$env/dynamic/private", async () => {
+	return {
+		env: {
+			...privateEnv,
+			// RVF store uses in-memory for tests (no file path = no persistence)
+			RVF_DB_PATH: "",
+		},
+	};
+});
+
+afterAll(async () => {
+	// No cleanup needed — RVF store is in-memory for tests
+});

package/src/ruvocal/scripts/updateLocalEnv.ts

@@ -0,0 +1,48 @@
+import fs from "fs";
+import yaml from "js-yaml";
+
+const file = fs.readFileSync("chart/env/prod.yaml", "utf8");
+
+// have to do a weird stringify/parse because of some node error
+const prod = JSON.parse(JSON.stringify(yaml.load(file)));
+const vars = prod.envVars as Record<string, string>;
+
+let PUBLIC_CONFIG = "";
+
+Object.entries(vars)
+	// filter keys used in prod with the proxy
+	.filter(
+		([key]) =>
+			![
+				"XFF_DEPTH",
+				"ADDRESS_HEADER",
+				"APP_BASE",
+				"PUBLIC_ORIGIN",
+				"PUBLIC_SHARE_PREFIX",
+				"ADMIN_CLI_LOGIN",
+			].includes(key)
+	)
+	.forEach(([key, value]) => {
+		PUBLIC_CONFIG += `${key}=\`${value}\`\n`;
+	});
+
+const SECRET_CONFIG =
+	(fs.existsSync(".env.SECRET_CONFIG")
+		? fs.readFileSync(".env.SECRET_CONFIG", "utf8")
+		: process.env.SECRET_CONFIG) ?? "";
+
+// Prepend the content of the env variable SECRET_CONFIG
+let full_config = `${PUBLIC_CONFIG}\n${SECRET_CONFIG}`;
+
+// replace the internal proxy url with the public endpoint
+full_config = full_config.replaceAll(
+	"https://internal.api-inference.huggingface.co",
+	"https://router.huggingface.co/hf-inference"
+);
+
+full_config = full_config.replaceAll("COOKIE_SECURE=`true`", "COOKIE_SECURE=`false`");
+full_config = full_config.replaceAll("LOG_LEVEL=`debug`", "LOG_LEVEL=`info`");
+full_config = full_config.replaceAll("NODE_ENV=`prod`", "NODE_ENV=`development`");
+
+// Write full_config to .env.local
+fs.writeFileSync(".env.local", full_config);

package/src/ruvocal/src/ambient.d.ts

@@ -0,0 +1,7 @@
+declare module "*.ttf" {
+	const value: ArrayBuffer;
+	export default value;
+}
+
+// Legacy helpers removed: web search support is deprecated, so we intentionally
+// avoid leaking those shapes into the global ambient types.

package/src/ruvocal/src/app.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="@sveltejs/kit" />
+/// <reference types="unplugin-icons/types/svelte" />
+
+import type { User } from "$lib/types/User";
+
+// See https://kit.svelte.dev/docs/types#app
+// for information about these interfaces
+declare global {
+	namespace App {
+		// interface Error {}
+		interface Locals {
+			sessionId: string;
+			user?: User;
+			isAdmin: boolean;
+			token?: string;
+			/** Organization to bill inference requests to (from settings) */
+			billingOrganization?: string;
+		}
+
+		interface Error {
+			message: string;
+			errorId?: ReturnType<typeof crypto.randomUUID>;
+		}
+		// interface PageData {}
+		// interface Platform {}
+	}
+}
+
+export {};

package/src/ruvocal/src/app.html

@@ -0,0 +1,53 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<meta
+			name="viewport"
+			content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no"
+		/>
+		<meta name="theme-color" content="rgb(249, 250, 251)" />
+		<script>
+			(function () {
+				try {
+					var prefersDark = window.matchMedia("(prefers-color-scheme: dark)").matches;
+					var stored = localStorage.getItem("theme");
+					var followSystem = stored === null || stored === "system";
+					var isDark = stored === "dark" || (followSystem && prefersDark);
+					if (isDark) {
+						document.documentElement.classList.add("dark");
+						document.querySelector('meta[name="theme-color"]').setAttribute("content", "#07090d");
+					}
+				} catch (e) {}
+			})();
+
+			// For some reason, Sveltekit doesn't let us load env variables from .env here, so we load it from hooks.server.ts
+			window.gaId = "%gaId%";
+		</script>
+		%sveltekit.head%
+	</head>
+	<body data-sveltekit-preload-data="hover" class="h-dvh dark:bg-gray-900">
+		<div id="app" class="contents h-full">%sveltekit.body%</div>
+
+		<!-- Google Tag Manager -->
+		<script>
+			if (window.gaId) {
+				const script = document.createElement("script");
+				script.src = "https://www.googletagmanager.com/gtag/js?id=" + window.gaId;
+				script.async = true;
+				document.head.appendChild(script);
+
+				window.dataLayer = window.dataLayer || [];
+				function gtag() {
+					dataLayer.push(arguments);
+				}
+				gtag("js", new Date());
+				/// ^ See https://developers.google.com/tag-platform/gtagjs/install
+				gtag("config", window.gaId);
+				gtag("consent", "default", { ad_storage: "denied", analytics_storage: "denied" });
+				/// ^ See https://developers.google.com/tag-platform/gtagjs/reference#consent
+				/// TODO: ask the user for their consent and update this with gtag('consent', 'update')
+			}
+		</script>
+	</body>
+</html>