ruflo 3.5.2 → 3.5.3

package/src/ruvocal/src/lib/migrations/routines/09-delete-empty-conversations.spec.ts

@@ -0,0 +1,214 @@
+import type { Session } from "$lib/types/Session";
+import type { User } from "$lib/types/User";
+import type { Conversation } from "$lib/types/Conversation";
+import { ObjectId } from "mongodb";
+import { deleteConversations } from "./09-delete-empty-conversations";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
+import { collections } from "$lib/server/database";
+
+type Message = Conversation["messages"][number];
+
+const userData = {
+	_id: new ObjectId(),
+	createdAt: new Date(),
+	updatedAt: new Date(),
+	username: "new-username",
+	name: "name",
+	avatarUrl: "https://example.com/avatar.png",
+	hfUserId: "9999999999",
+} satisfies User;
+Object.freeze(userData);
+
+const sessionForUser = {
+	_id: new ObjectId(),
+	createdAt: new Date(),
+	updatedAt: new Date(),
+	userId: userData._id,
+	sessionId: "session-id-9999999999",
+	expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24),
+} satisfies Session;
+Object.freeze(sessionForUser);
+
+const userMessage = {
+	from: "user",
+	id: "user-message-id",
+	content: "Hello, how are you?",
+} satisfies Message;
+
+const assistantMessage = {
+	from: "assistant",
+	id: "assistant-message-id",
+	content: "I'm fine, thank you!",
+} satisfies Message;
+
+const systemMessage = {
+	from: "system",
+	id: "system-message-id",
+	content: "This is a system message",
+} satisfies Message;
+
+const conversationBase = {
+	_id: new ObjectId(),
+	createdAt: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+	updatedAt: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+	model: "model-id",
+
+	title: "title",
+	messages: [],
+} satisfies Conversation;
+
+describe.sequential("Deleting discarded conversations", async () => {
+	test("a conversation with no messages should get deleted", async () => {
+		await collections.conversations.insertOne({
+			...conversationBase,
+			sessionId: sessionForUser.sessionId,
+		});
+
+		const result = await deleteConversations(collections);
+
+		expect(result).toBe(1);
+	});
+	test("a conversation with no messages that is less than 1 hour old should not get deleted", async () => {
+		await collections.conversations.insertOne({
+			...conversationBase,
+			sessionId: sessionForUser.sessionId,
+			createdAt: new Date(Date.now() - 30 * 60 * 1000),
+		});
+
+		const result = await deleteConversations(collections);
+
+		expect(result).toBe(0);
+	});
+	test("a conversation with only system messages should get deleted", async () => {
+		await collections.conversations.insertOne({
+			...conversationBase,
+			sessionId: sessionForUser.sessionId,
+			messages: [systemMessage],
+		});
+
+		const result = await deleteConversations(collections);
+
+		expect(result).toBe(1);
+	});
+	test("a conversation with a user message should not get deleted", async () => {
+		await collections.conversations.insertOne({
+			...conversationBase,
+			sessionId: sessionForUser.sessionId,
+			messages: [userMessage],
+		});
+
+		const result = await deleteConversations(collections);
+
+		expect(result).toBe(0);
+	});
+	test("a conversation with an assistant message should not get deleted", async () => {
+		await collections.conversations.insertOne({
+			...conversationBase,
+			sessionId: sessionForUser.sessionId,
+			messages: [assistantMessage],
+		});
+
+		const result = await deleteConversations(collections);
+
+		expect(result).toBe(0);
+	});
+	test("a conversation with a mix of messages should not get deleted", async () => {
+		await collections.conversations.insertOne({
+			...conversationBase,
+			sessionId: sessionForUser.sessionId,
+			messages: [systemMessage, userMessage, assistantMessage, userMessage, assistantMessage],
+		});
+
+		const result = await deleteConversations(collections);
+
+		expect(result).toBe(0);
+	});
+	test("a conversation with a userId and no sessionId should not get deleted", async () => {
+		await collections.conversations.insertOne({
+			...conversationBase,
+			messages: [userMessage, assistantMessage],
+			userId: userData._id,
+		});
+
+		const result = await deleteConversations(collections);
+
+		expect(result).toBe(0);
+	});
+	test("a conversation with no userId or sessionId should get deleted", async () => {
+		await collections.conversations.insertOne({
+			...conversationBase,
+			messages: [userMessage, assistantMessage],
+		});
+
+		const result = await deleteConversations(collections);
+
+		expect(result).toBe(1);
+	});
+	test("a conversation with a sessionId that exists should not get deleted", async () => {
+		await collections.conversations.insertOne({
+			...conversationBase,
+			messages: [userMessage, assistantMessage],
+			sessionId: sessionForUser.sessionId,
+		});
+
+		const result = await deleteConversations(collections);
+
+		expect(result).toBe(0);
+	});
+	test("a conversation with a userId and a sessionId that doesn't exist should NOT get deleted", async () => {
+		await collections.conversations.insertOne({
+			...conversationBase,
+			userId: userData._id,
+			messages: [userMessage, assistantMessage],
+			sessionId: new ObjectId().toString(),
+		});
+
+		const result = await deleteConversations(collections);
+
+		expect(result).toBe(0);
+	});
+	test("a conversation with only a sessionId that doesn't exist, should get deleted", async () => {
+		await collections.conversations.insertOne({
+			...conversationBase,
+			messages: [userMessage, assistantMessage],
+			sessionId: new ObjectId().toString(),
+		});
+
+		const result = await deleteConversations(collections);
+
+		expect(result).toBe(1);
+	});
+	test("many conversations should get deleted", async () => {
+		const conversations = Array.from({ length: 10010 }, () => ({
+			...conversationBase,
+			_id: new ObjectId(),
+		}));
+
+		await collections.conversations.insertMany(conversations);
+
+		const result = await deleteConversations(collections);
+
+		expect(result).toBe(10010);
+	});
+});
+
+beforeAll(async () => {
+	await collections.users.insertOne(userData);
+	await collections.sessions.insertOne(sessionForUser);
+}, 20000);
+
+afterAll(async () => {
+	await collections.users.deleteOne({
+		_id: userData._id,
+	});
+	await collections.sessions.deleteOne({
+		_id: sessionForUser._id,
+	});
+	await collections.conversations.deleteMany({});
+});
+
+afterEach(async () => {
+	await collections.conversations.deleteMany({
+		_id: { $in: [conversationBase._id] },
+	});
+});

package/src/ruvocal/src/lib/migrations/routines/09-delete-empty-conversations.ts

@@ -0,0 +1,88 @@
+import type { Migration } from ".";
+import { collections } from "$lib/server/database";
+import { Collection, FindCursor, ObjectId } from "mongodb";
+import { logger } from "$lib/server/logger";
+import type { Conversation } from "$lib/types/Conversation";
+
+const BATCH_SIZE = 1000;
+const DELETE_THRESHOLD_MS = 60 * 60 * 1000;
+
+async function deleteBatch(conversations: Collection<Conversation>, ids: ObjectId[]) {
+	if (ids.length === 0) return 0;
+	const deleteResult = await conversations.deleteMany({ _id: { $in: ids } });
+	return deleteResult.deletedCount;
+}
+
+async function processCursor<T>(
+	cursor: FindCursor<T>,
+	processBatchFn: (batch: T[]) => Promise<void>
+) {
+	let batch = [];
+	while (await cursor.hasNext()) {
+		const doc = await cursor.next();
+		if (doc) {
+			batch.push(doc);
+		}
+		if (batch.length >= BATCH_SIZE) {
+			await processBatchFn(batch);
+			batch = [];
+		}
+	}
+	if (batch.length > 0) {
+		await processBatchFn(batch);
+	}
+}
+
+export async function deleteConversations(
+	collections: typeof import("$lib/server/database").collections
+) {
+	let deleteCount = 0;
+	const { conversations, sessions } = collections;
+
+	// First criteria: Delete conversations with no user/assistant messages older than 1 hour
+	const emptyConvCursor = conversations
+		.find({
+			"messages.from": { $not: { $in: ["user", "assistant"] } },
+			createdAt: { $lt: new Date(Date.now() - DELETE_THRESHOLD_MS) },
+		})
+		.batchSize(BATCH_SIZE);
+
+	await processCursor(emptyConvCursor, async (batch) => {
+		const ids = batch.map((doc) => doc._id);
+		deleteCount += await deleteBatch(conversations, ids);
+	});
+
+	// Second criteria: Process conversations without users in batches and check sessions
+	const noUserCursor = conversations.find({ userId: { $exists: false } }).batchSize(BATCH_SIZE);
+
+	await processCursor(noUserCursor, async (batch) => {
+		const sessionIds = [
+			...new Set(batch.map((conv) => conv.sessionId).filter((id): id is string => !!id)),
+		];
+
+		const existingSessions = await sessions.find({ sessionId: { $in: sessionIds } }).toArray();
+		const validSessionIds = new Set(existingSessions.map((s) => s.sessionId));
+
+		const invalidConvs = batch.filter(
+			(conv) => !conv.sessionId || !validSessionIds.has(conv.sessionId)
+		);
+		const idsToDelete = invalidConvs.map((conv) => conv._id);
+		deleteCount += await deleteBatch(conversations, idsToDelete);
+	});
+
+	logger.info(`[MIGRATIONS] Deleted ${deleteCount} conversations in total.`);
+	return deleteCount;
+}
+
+const deleteEmptyConversations: Migration = {
+	_id: new ObjectId("000000000000000000000009"),
+	name: "Delete conversations with no user or assistant messages or valid sessions",
+	up: async () => {
+		await deleteConversations(collections);
+		return true;
+	},
+	runEveryTime: false,
+	runForHuggingChat: "only",
+};
+
+export default deleteEmptyConversations;

package/src/ruvocal/src/lib/migrations/routines/10-update-reports-assistantid.ts

@@ -0,0 +1,29 @@
+import { collections } from "$lib/server/database";
+import type { Migration } from ".";
+import { ObjectId } from "mongodb";
+
+const migration: Migration = {
+	_id: new ObjectId("000000000000000000000010"),
+	name: "Update reports with assistantId to use contentId",
+	up: async () => {
+		await collections.reports.updateMany(
+			{
+				assistantId: { $exists: true, $ne: null },
+			},
+			[
+				{
+					$set: {
+						object: "assistant",
+						contentId: "$assistantId",
+					},
+				},
+				{
+					$unset: "assistantId",
+				},
+			]
+		);
+		return true;
+	},
+};
+
+export default migration;

package/src/ruvocal/src/lib/migrations/routines/index.ts

@@ -0,0 +1,15 @@
+import type { ObjectId } from "mongodb";
+
+import type { Database } from "$lib/server/database";
+
+export interface Migration {
+	_id: ObjectId;
+	name: string;
+	up: (client: Database) => Promise<boolean>;
+	down?: (client: Database) => Promise<boolean>;
+	runForFreshInstall?: "only" | "never"; // leave unspecified to run for both
+	runForHuggingChat?: "only" | "never"; // leave unspecified to run for both
+	runEveryTime?: boolean;
+}
+
+export const migrations: Migration[] = [];

package/src/ruvocal/src/lib/server/__tests__/conversation-stop-generating.spec.ts

@@ -0,0 +1,103 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { ObjectId } from "mongodb";
+
+import { collections } from "$lib/server/database";
+import { AbortRegistry } from "$lib/server/abortRegistry";
+import {
+	cleanupTestData,
+	createTestConversation,
+	createTestLocals,
+	createTestUser,
+} from "$lib/server/api/__tests__/testHelpers";
+import { POST } from "../../../routes/conversation/[id]/stop-generating/+server";
+
+describe.sequential("POST /conversation/[id]/stop-generating", () => {
+	afterEach(async () => {
+		vi.restoreAllMocks();
+		await cleanupTestData();
+	});
+
+	it(
+		"creates abort marker and aborts active registry controllers",
+		{ timeout: 30000 },
+		async () => {
+			const { locals } = await createTestUser();
+			const conversation = await createTestConversation(locals);
+			const abortSpy = vi.spyOn(AbortRegistry.getInstance(), "abort");
+
+			const response = await POST({
+				params: { id: conversation._id.toString() },
+				locals,
+			} as never);
+
+			expect(response.status).toBe(200);
+			expect(abortSpy).toHaveBeenCalledWith(conversation._id.toString());
+
+			const marker = await collections.abortedGenerations.findOne({
+				conversationId: conversation._id,
+			});
+			expect(marker).not.toBeNull();
+			expect(marker?.createdAt).toBeInstanceOf(Date);
+			expect(marker?.updatedAt).toBeInstanceOf(Date);
+		}
+	);
+
+	it("updates updatedAt while preserving createdAt on repeated stop", async () => {
+		const { locals } = await createTestUser();
+		const conversation = await createTestConversation(locals);
+
+		await POST({
+			params: { id: conversation._id.toString() },
+			locals,
+		} as never);
+		const firstMarker = await collections.abortedGenerations.findOne({
+			conversationId: conversation._id,
+		});
+
+		await new Promise((resolve) => setTimeout(resolve, 5));
+
+		await POST({
+			params: { id: conversation._id.toString() },
+			locals,
+		} as never);
+		const secondMarker = await collections.abortedGenerations.findOne({
+			conversationId: conversation._id,
+		});
+
+		expect(firstMarker).not.toBeNull();
+		expect(secondMarker).not.toBeNull();
+		expect(secondMarker?.createdAt.getTime()).toBe(firstMarker?.createdAt.getTime());
+		expect(secondMarker?.updatedAt.getTime()).toBeGreaterThan(
+			firstMarker?.updatedAt.getTime() ?? 0
+		);
+	});
+
+	it("throws 404 when conversation is not found", async () => {
+		const { locals } = await createTestUser();
+		const missingId = new ObjectId().toString();
+
+		try {
+			await POST({
+				params: { id: missingId },
+				locals,
+			} as never);
+			expect.fail("Expected 404 error");
+		} catch (e: unknown) {
+			expect((e as { status: number }).status).toBe(404);
+		}
+	});
+
+	it("throws 401 for unauthenticated requests", async () => {
+		const locals = createTestLocals({ user: undefined, sessionId: undefined });
+
+		try {
+			await POST({
+				params: { id: new ObjectId().toString() },
+				locals,
+			} as never);
+			expect.fail("Expected 401 error");
+		} catch (e: unknown) {
+			expect((e as { status: number }).status).toBe(401);
+		}
+	});
+});

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

@@ -0,0 +1,57 @@
+import { logger } from "$lib/server/logger";
+
+/**
+ * Tracks active upstream generation requests so they can be cancelled on demand.
+ * Multiple controllers can be registered per conversation (for threaded/background runs).
+ */
+export class AbortRegistry {
+	private static instance: AbortRegistry;
+
+	private controllers = new Map<string, Set<AbortController>>();
+
+	public static getInstance(): AbortRegistry {
+		if (!AbortRegistry.instance) {
+			AbortRegistry.instance = new AbortRegistry();
+		}
+		return AbortRegistry.instance;
+	}
+
+	public register(conversationId: string, controller: AbortController) {
+		const key = conversationId.toString();
+		let set = this.controllers.get(key);
+		if (!set) {
+			set = new Set();
+			this.controllers.set(key, set);
+		}
+		set.add(controller);
+		controller.signal.addEventListener(
+			"abort",
+			() => {
+				this.unregister(key, controller);
+			},
+			{ once: true }
+		);
+	}
+
+	public abort(conversationId: string) {
+		const set = this.controllers.get(conversationId);
+		if (!set?.size) return;
+
+		logger.debug({ conversationId }, "Aborting active generation via AbortRegistry");
+		for (const controller of set) {
+			if (!controller.signal.aborted) {
+				controller.abort();
+			}
+		}
+		this.controllers.delete(conversationId);
+	}
+
+	public unregister(conversationId: string, controller: AbortController) {
+		const set = this.controllers.get(conversationId);
+		if (!set) return;
+		set.delete(controller);
+		if (set.size === 0) {
+			this.controllers.delete(conversationId);
+		}
+	}
+}

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

@@ -0,0 +1,43 @@
+// Shouldn't be needed if we dove into sveltekit internals, see https://github.com/huggingface/chat-ui/pull/88#issuecomment-1523173850
+
+import { logger } from "$lib/server/logger";
+import { collections } from "$lib/server/database";
+import { onExit } from "./exitHandler";
+
+export class AbortedGenerations {
+	private static instance: AbortedGenerations;
+
+	private abortedGenerations: Record<string, Date> = {};
+
+	private constructor() {
+		// Poll every 500ms for faster abort detection (reduced from 1000ms)
+		const interval = setInterval(() => this.updateList(), 500);
+		onExit(() => clearInterval(interval));
+
+		this.updateList();
+	}
+
+	public static getInstance(): AbortedGenerations {
+		if (!AbortedGenerations.instance) {
+			AbortedGenerations.instance = new AbortedGenerations();
+		}
+
+		return AbortedGenerations.instance;
+	}
+
+	public getAbortTime(conversationId: string): Date | undefined {
+		return this.abortedGenerations[conversationId];
+	}
+
+	private async updateList() {
+		try {
+			const aborts = await collections.abortedGenerations.find({}).sort({ createdAt: 1 }).toArray();
+
+			this.abortedGenerations = Object.fromEntries(
+				aborts.map((abort) => [abort.conversationId.toString(), abort.updatedAt ?? abort.createdAt])
+			);
+		} catch (err) {
+			logger.error(err, "Error updating aborted generations list");
+		}
+	}
+}

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

@@ -0,0 +1,62 @@
+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 = 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 config.ADMIN_CLI_LOGIN === "true";
+	}
+	public isAdmin(sessionId: Session["sessionId"]) {
+		if (!this.enabled) return false;
+		return this.adminSessions.includes(sessionId);
+	}
+
+	public checkToken(token: string, sessionId: Session["sessionId"]) {
+		if (!this.enabled) return false;
+		if (token === this.token) {
+			logger.info(`[ADMIN] Token validated`);
+			this.adminSessions.push(sessionId);
+			this.token = config.ADMIN_TOKEN || v4();
+			return true;
+		}
+
+		return false;
+	}
+
+	public removeSession(sessionId: Session["sessionId"]) {
+		this.adminSessions = this.adminSessions.filter((id) => id !== sessionId);
+	}
+
+	public displayToken() {
+		// if admin token is set, don't display it
+		if (!this.enabled || config.ADMIN_TOKEN) return;
+
+		let port = process.env.PORT
+			? parseInt(process.env.PORT)
+			: process.argv.includes("--port")
+				? parseInt(process.argv[process.argv.indexOf("--port") + 1])
+				: undefined;
+
+		if (!port) {
+			const mode = process.argv.find((arg) => arg === "preview" || arg === "dev");
+			if (mode === "preview") {
+				port = 4173;
+			} else if (mode === "dev") {
+				port = 5173;
+			} else {
+				port = 3000;
+			}
+		}
+
+		const url = (config.PUBLIC_ORIGIN || `http://localhost:${port}`) + "?token=";
+		logger.info(`[ADMIN] You can login with ${url + this.token}`);
+	}
+}
+
+export const adminTokenManager = new AdminTokenManager();