ruflo 3.5.1 → 3.5.3

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

@@ -0,0 +1,72 @@
+import { Address4, Address6 } from "ip-address";
+import { isIP } from "node:net";
+
+const UNSAFE_IPV4_SUBNETS = [
+	"0.0.0.0/8",
+	"100.64.0.0/10",
+	"127.0.0.0/8",
+	"169.254.0.0/16",
+	"172.16.0.0/12",
+	"192.168.0.0/16",
+].map((s) => new Address4(s));
+
+function isUnsafeIp(address: string): boolean {
+	const family = isIP(address);
+
+	if (family === 4) {
+		const addr = new Address4(address);
+		return UNSAFE_IPV4_SUBNETS.some((subnet) => addr.isInSubnet(subnet));
+	}
+
+	if (family === 6) {
+		const addr = new Address6(address);
+		// Check IPv4-mapped IPv6 addresses (e.g. ::ffff:127.0.0.1)
+		if (addr.is4()) {
+			const v4 = addr.to4();
+			return UNSAFE_IPV4_SUBNETS.some((subnet) => v4.isInSubnet(subnet));
+		}
+		return addr.isLoopback() || addr.isLinkLocal();
+	}
+
+	return true; // Unknown format → block
+}
+
+/**
+ * Synchronous URL validation: checks protocol and hostname string.
+ */
+export function isValidUrl(urlString: string): boolean {
+	try {
+		const url = new URL(urlString.trim());
+		const hostname = url.hostname.toLowerCase();
+		// Allow HTTP for localhost/loopback (dev & local MCP bridge)
+		if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1") {
+			return url.protocol === "http:" || url.protocol === "https:";
+		}
+		// Allow HTTP for Docker-internal service names (no dots = private network)
+		if (!hostname.includes(".") && url.protocol === "http:") {
+			return true;
+		}
+		if (url.protocol !== "https:") {
+			return false;
+		}
+		// If the hostname is a raw IP literal, validate it
+		const cleanHostname = hostname.replace(/^\[|]$/g, "");
+		if (isIP(cleanHostname)) {
+			return !isUnsafeIp(cleanHostname);
+		}
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Assert that a resolved IP address is safe (not internal/private).
+ * Throws if the IP is internal. Used in undici's custom DNS lookup
+ * to validate IPs at connection time (prevents TOCTOU DNS rebinding).
+ */
+export function assertSafeIp(address: string, hostname: string): void {
+	if (isUnsafeIp(address)) {
+		throw new Error(`Resolved IP for ${hostname} is internal (${address})`);
+	}
+}

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { config } from "$lib/server/config";
+import JSON5 from "json5";
+
+const sanitizeJSONEnv = (val: string, fallback: string) => {
+	const raw = (val ?? "").trim();
+	const unquoted = raw.startsWith("`") && raw.endsWith("`") ? raw.slice(1, -1) : raw;
+	return unquoted || fallback;
+};
+
+// RATE_LIMIT is the legacy way to define messages per minute limit
+export const usageLimitsSchema = z
+	.object({
+		conversations: z.coerce.number().optional(), // how many conversations
+		messages: z.coerce.number().optional(), // how many messages in a conversation
+		messageLength: z.coerce.number().optional(), // how long can a message be before we cut it off
+		messagesPerMinute: z
+			.preprocess((val) => {
+				if (val === undefined) {
+					return config.RATE_LIMIT;
+				}
+				return val;
+			}, z.coerce.number().optional())
+			.optional(), // how many messages per minute
+	})
+	.optional();
+
+export const usageLimits = usageLimitsSchema.parse(
+	JSON5.parse(sanitizeJSONEnv(config.USAGE_LIMITS, "{}"))
+);

package/src/ruvocal/src/lib/stores/autopilotStore.svelte.ts

@@ -0,0 +1,175 @@
+/**
+ * Autopilot Store — Svelte 5 runes-based store for managing autopilot Web Worker state.
+ *
+ * Provides reactive state for autopilot groups, tasks, and text content.
+ * Communicates with AutopilotWorker and DetailFetchWorker via postMessage.
+ *
+ * ADR-037 Part 2+3: Parallel Task UI + Web Workers
+ */
+
+import type { GroupState, AutopilotUIUpdate } from "$lib/workers/autopilotWorker";
+import type { DetailWorkerOutgoing } from "$lib/workers/detailFetchWorker";
+
+export interface AutopilotState {
+	active: boolean;
+	maxSteps: number;
+	groups: GroupState[];
+	textContent: string;
+	error: string | null;
+	totalSteps: number;
+	totalTasks: number;
+	duration: number;
+	paused: boolean;
+	pauseReason: string | null;
+}
+
+const defaultState: AutopilotState = {
+	active: false,
+	maxSteps: 20,
+	groups: [],
+	textContent: "",
+	error: null,
+	totalSteps: 0,
+	totalTasks: 0,
+	duration: 0,
+	paused: false,
+	pauseReason: null,
+};
+
+let state = $state<AutopilotState>({ ...defaultState });
+
+let autopilotWorker: Worker | null = null;
+let detailWorker: Worker | null = null;
+const detailCallbacks = new Map<string, (content: string | null, error?: string) => void>();
+
+async function ensureWorkers() {
+	if (typeof window === "undefined") return;
+
+	if (!autopilotWorker) {
+		const mod = await import("$lib/workers/autopilotWorker?worker");
+		autopilotWorker = new mod.default();
+		autopilotWorker.onmessage = handleWorkerMessage;
+	}
+
+	if (!detailWorker) {
+		const mod = await import("$lib/workers/detailFetchWorker?worker");
+		detailWorker = new mod.default();
+		detailWorker.onmessage = handleDetailMessage;
+	}
+}
+
+function handleWorkerMessage(e: MessageEvent) {
+	const msg = e.data;
+
+	switch (msg.type) {
+		case "batch_update":
+			state.groups = msg.groups;
+			for (const update of msg.updates as AutopilotUIUpdate[]) {
+				applyUpdate(update);
+			}
+			break;
+
+		case "text":
+			state.textContent += msg.content;
+			break;
+
+		case "done":
+			state.active = false;
+			state.groups = msg.groups;
+			break;
+
+		case "error":
+			state.active = false;
+			state.error = msg.error;
+			break;
+
+		case "stopped":
+			state.active = false;
+			state.groups = msg.groups;
+			break;
+	}
+}
+
+function applyUpdate(update: AutopilotUIUpdate) {
+	switch (update.type) {
+		case "start":
+			state.maxSteps = update.maxSteps;
+			break;
+		case "end":
+			state.totalSteps = update.totalSteps;
+			state.totalTasks = update.totalTasks;
+			state.duration = update.duration;
+			break;
+		case "text":
+			state.textContent += update.content;
+			break;
+		case "paused":
+			state.paused = true;
+			state.pauseReason = update.reason;
+			break;
+		case "error_event":
+			state.error = update.error;
+			break;
+	}
+}
+
+function handleDetailMessage(e: MessageEvent<DetailWorkerOutgoing>) {
+	const msg = e.data;
+	if (msg.type === "detail") {
+		const cb = detailCallbacks.get(msg.detailToken);
+		if (cb) {
+			cb(msg.content);
+			detailCallbacks.delete(msg.detailToken);
+		}
+	} else if (msg.type === "detail_error") {
+		const cb = detailCallbacks.get(msg.detailToken);
+		if (cb) {
+			cb(null, msg.error);
+			detailCallbacks.delete(msg.detailToken);
+		}
+	}
+}
+
+export function useAutopilot() {
+	return {
+		get state() {
+			return state;
+		},
+
+		async start(url: string, headers: Record<string, string>, body: unknown) {
+			await ensureWorkers();
+			Object.assign(state, { ...defaultState, active: true });
+			autopilotWorker?.postMessage({ type: "start", url, headers, body });
+		},
+
+		stop() {
+			autopilotWorker?.postMessage({ type: "stop" });
+		},
+
+		async fetchDetail(detailToken: string, bridgeUrl: string): Promise<string> {
+			await ensureWorkers();
+			return new Promise((resolve, reject) => {
+				detailCallbacks.set(detailToken, (content, error) => {
+					if (error) reject(new Error(error));
+					else resolve(content!);
+				});
+				detailWorker?.postMessage({ type: "fetch", detailToken, bridgeUrl });
+			});
+		},
+
+		prefetchDetail(detailToken: string, bridgeUrl: string) {
+			detailWorker?.postMessage({ type: "prefetch", detailToken, bridgeUrl });
+		},
+
+		evictDetail(detailToken: string) {
+			detailWorker?.postMessage({ type: "evict", detailToken });
+		},
+
+		destroy() {
+			autopilotWorker?.terminate();
+			detailWorker?.terminate();
+			autopilotWorker = null;
+			detailWorker = null;
+		},
+	};
+}

package/src/ruvocal/src/lib/stores/backgroundGenerations.svelte.ts

@@ -0,0 +1,32 @@
+export type BackgroundGeneration = {
+	id: string;
+	startedAt: number;
+};
+
+export const backgroundGenerationEntries = $state<BackgroundGeneration[]>([]);
+
+export function addBackgroundGeneration(entry: BackgroundGeneration) {
+	const index = backgroundGenerationEntries.findIndex(({ id }) => id === entry.id);
+
+	if (index === -1) {
+		backgroundGenerationEntries.push(entry);
+		return;
+	}
+
+	backgroundGenerationEntries[index] = entry;
+}
+
+export function removeBackgroundGeneration(id: string) {
+	const index = backgroundGenerationEntries.findIndex((entry) => entry.id === id);
+	if (index === -1) return;
+
+	backgroundGenerationEntries.splice(index, 1);
+}
+
+export function clearBackgroundGenerations() {
+	backgroundGenerationEntries.length = 0;
+}
+
+export function hasBackgroundGeneration(id: string) {
+	return backgroundGenerationEntries.some((entry) => entry.id === id);
+}

package/src/ruvocal/src/lib/stores/backgroundGenerations.ts

@@ -0,0 +1 @@
+export * from "./backgroundGenerations.svelte";

package/src/ruvocal/src/lib/stores/errors.ts

@@ -0,0 +1,9 @@
+import { writable } from "svelte/store";
+
+export const ERROR_MESSAGES = {
+	default: "Oops, something went wrong.",
+	authOnly: "You have to be logged in.",
+	rateLimited: "You are sending too many messages. Try again later.",
+};
+
+export const error = writable<string | undefined>(undefined);

package/src/ruvocal/src/lib/stores/isAborted.ts

@@ -0,0 +1,3 @@
+import { writable } from "svelte/store";
+
+export const isAborted = writable<boolean>(false);

package/src/ruvocal/src/lib/stores/isPro.ts

@@ -0,0 +1,4 @@
+import { writable } from "svelte/store";
+
+// null = unknown/loading, true = PRO, false = not PRO
+export const isPro = writable<boolean | null>(null);

package/src/ruvocal/src/lib/stores/loading.ts

@@ -0,0 +1,3 @@
+import { writable } from "svelte/store";
+
+export const loading = writable(false);

package/src/ruvocal/src/lib/stores/mcpServers.ts

@@ -0,0 +1,345 @@
+/**
+ * MCP Servers Store
+ * Manages base (env-configured) and custom (user-added) MCP servers
+ * Stores custom servers and selection state in browser localStorage
+ */
+
+import { writable, derived, get } from "svelte/store";
+import { base } from "$app/paths";
+import { env as publicEnv } from "$env/dynamic/public";
+import { browser } from "$app/environment";
+import type { MCPServer, ServerStatus, MCPTool } from "$lib/types/Tool";
+
+// Namespace storage by app identity to avoid collisions across apps
+function toKeyPart(s: string | undefined): string {
+	return (s || "").toLowerCase().replace(/[^a-z0-9_-]+/g, "-");
+}
+
+const appLabel = toKeyPart(publicEnv.PUBLIC_APP_ASSETS || publicEnv.PUBLIC_APP_NAME);
+const baseLabel = toKeyPart(typeof base === "string" ? base : "");
+// Final prefix format requested: "huggingchat:key" (no mcp:/chat)
+const KEY_PREFIX = appLabel || baseLabel || "app";
+
+const STORAGE_KEYS = {
+	CUSTOM_SERVERS: `${KEY_PREFIX}:mcp:custom-servers`,
+	SELECTED_IDS: `${KEY_PREFIX}:mcp:selected-ids`,
+	DISABLED_BASE_IDS: `${KEY_PREFIX}:mcp:disabled-base-ids`,
+} as const;
+
+// No migration needed per request — read/write only namespaced keys
+
+// Load custom servers from localStorage
+function loadCustomServers(): MCPServer[] {
+	if (!browser) return [];
+
+	try {
+		const json = localStorage.getItem(STORAGE_KEYS.CUSTOM_SERVERS);
+		return json ? JSON.parse(json) : [];
+	} catch (error) {
+		console.error("Failed to load custom MCP servers from localStorage:", error);
+		return [];
+	}
+}
+
+// Load selected server IDs from localStorage
+function loadSelectedIds(): Set<string> {
+	if (!browser) return new Set();
+
+	try {
+		const json = localStorage.getItem(STORAGE_KEYS.SELECTED_IDS);
+		const ids: string[] = json ? JSON.parse(json) : [];
+		return new Set(ids);
+	} catch (error) {
+		console.error("Failed to load selected MCP server IDs from localStorage:", error);
+		return new Set();
+	}
+}
+
+// Save custom servers to localStorage
+function saveCustomServers(servers: MCPServer[]) {
+	if (!browser) return;
+
+	try {
+		localStorage.setItem(STORAGE_KEYS.CUSTOM_SERVERS, JSON.stringify(servers));
+	} catch (error) {
+		console.error("Failed to save custom MCP servers to localStorage:", error);
+	}
+}
+
+// Save selected IDs to localStorage
+function saveSelectedIds(ids: Set<string>) {
+	if (!browser) return;
+
+	try {
+		localStorage.setItem(STORAGE_KEYS.SELECTED_IDS, JSON.stringify([...ids]));
+	} catch (error) {
+		console.error("Failed to save selected MCP server IDs to localStorage:", error);
+	}
+}
+
+// Load disabled base server IDs from localStorage (empty set if missing or on error)
+function loadDisabledBaseIds(): Set<string> {
+	if (!browser) return new Set();
+
+	try {
+		const json = localStorage.getItem(STORAGE_KEYS.DISABLED_BASE_IDS);
+		return new Set(json ? JSON.parse(json) : []);
+	} catch (error) {
+		console.error("Failed to load disabled base MCP server IDs from localStorage:", error);
+		return new Set();
+	}
+}
+
+// Save disabled base server IDs to localStorage
+function saveDisabledBaseIds(ids: Set<string>) {
+	if (!browser) return;
+
+	try {
+		localStorage.setItem(STORAGE_KEYS.DISABLED_BASE_IDS, JSON.stringify([...ids]));
+	} catch (error) {
+		console.error("Failed to save disabled base MCP server IDs to localStorage:", error);
+	}
+}
+
+// Store for all servers (base + custom)
+export const allMcpServers = writable<MCPServer[]>([]);
+
+// Track if initial server load has completed
+export const mcpServersLoaded = writable<boolean>(false);
+
+// Store for selected server IDs
+export const selectedServerIds = writable<Set<string>>(loadSelectedIds());
+
+// Auto-persist selected IDs when they change
+if (browser) {
+	selectedServerIds.subscribe((ids) => {
+		saveSelectedIds(ids);
+	});
+}
+
+// Derived store: only enabled servers
+export const enabledServers = derived([allMcpServers, selectedServerIds], ([$all, $selected]) =>
+	$all.filter((s) => $selected.has(s.id))
+);
+
+// Derived store: count of enabled servers
+export const enabledServersCount = derived(enabledServers, ($enabled) => $enabled.length);
+
+// Derived store: true if all base servers are enabled
+export const allBaseServersEnabled = derived(
+	[allMcpServers, selectedServerIds],
+	([$all, $selected]) => {
+		const baseServers = $all.filter((s) => s.type === "base");
+		return baseServers.length > 0 && baseServers.every((s) => $selected.has(s.id));
+	}
+);
+
+// Note: Authorization overlay (with user's HF token) for the Hugging Face MCP host
+// is applied server-side when enabled via MCP_FORWARD_HF_USER_TOKEN.
+
+/**
+ * Refresh base servers from API and merge with custom servers
+ */
+export async function refreshMcpServers() {
+	try {
+		const response = await fetch(`${base}/api/mcp/servers`);
+		if (!response.ok) {
+			throw new Error(`Failed to fetch base servers: ${response.statusText}`);
+		}
+
+		const baseServers: MCPServer[] = await response.json();
+		const customServers = loadCustomServers();
+
+		// Merge base and custom servers
+		const merged = [...baseServers, ...customServers];
+		allMcpServers.set(merged);
+
+		// Load disabled base servers
+		const disabledBaseIds = loadDisabledBaseIds();
+
+		// Auto-enable all base servers that aren't explicitly disabled
+		// Plus keep any custom servers that were previously selected
+		const validIds = new Set(merged.map((s) => s.id));
+		selectedServerIds.update(($currentIds) => {
+			const newSelection = new Set<string>();
+
+			// Add all base servers that aren't disabled
+			for (const server of baseServers) {
+				if (!disabledBaseIds.has(server.id)) {
+					newSelection.add(server.id);
+				}
+			}
+
+			// Keep custom servers that were selected and still exist
+			for (const id of $currentIds) {
+				if (validIds.has(id) && !id.startsWith("base-")) {
+					newSelection.add(id);
+				}
+			}
+
+			return newSelection;
+		});
+		mcpServersLoaded.set(true);
+	} catch (error) {
+		console.error("Failed to refresh MCP servers:", error);
+		// On error, just use custom servers
+		allMcpServers.set(loadCustomServers());
+		mcpServersLoaded.set(true);
+	}
+}
+
+/**
+ * Toggle a server on/off
+ */
+export function toggleServer(id: string) {
+	selectedServerIds.update(($ids) => {
+		const newSet = new Set($ids);
+		if (newSet.has(id)) {
+			newSet.delete(id);
+			// Track if this is a base server being disabled
+			if (id.startsWith("base-")) {
+				const disabled = loadDisabledBaseIds();
+				disabled.add(id);
+				saveDisabledBaseIds(disabled);
+			}
+		} else {
+			newSet.add(id);
+			// Remove from disabled if re-enabling a base server
+			if (id.startsWith("base-")) {
+				const disabled = loadDisabledBaseIds();
+				disabled.delete(id);
+				saveDisabledBaseIds(disabled);
+			}
+		}
+		return newSet;
+	});
+}
+
+/**
+ * Disable all MCP servers (marks all base servers as disabled)
+ */
+export function disableAllServers() {
+	// Get current base server IDs and mark them all as disabled
+	const servers = get(allMcpServers);
+	const baseServerIds = servers.filter((s) => s.type === "base").map((s) => s.id);
+
+	// Save all base servers as disabled
+	saveDisabledBaseIds(new Set(baseServerIds));
+
+	// Clear the selection
+	selectedServerIds.set(new Set());
+}
+
+/**
+ * Add a custom MCP server
+ */
+export function addCustomServer(server: Omit<MCPServer, "id" | "type" | "status">): string {
+	const newServer: MCPServer = {
+		...server,
+		id: crypto.randomUUID(),
+		type: "custom",
+		status: "disconnected",
+	};
+
+	const customServers = loadCustomServers();
+	customServers.push(newServer);
+	saveCustomServers(customServers);
+
+	// Refresh all servers to include the new one
+	refreshMcpServers();
+
+	return newServer.id;
+}
+
+/**
+ * Update an existing custom server
+ */
+export function updateCustomServer(id: string, updates: Partial<MCPServer>) {
+	const customServers = loadCustomServers();
+	const index = customServers.findIndex((s) => s.id === id);
+
+	if (index !== -1) {
+		customServers[index] = { ...customServers[index], ...updates };
+		saveCustomServers(customServers);
+		refreshMcpServers();
+	}
+}
+
+/**
+ * Delete a custom server
+ */
+export function deleteCustomServer(id: string) {
+	const customServers = loadCustomServers();
+	const filtered = customServers.filter((s) => s.id !== id);
+	saveCustomServers(filtered);
+
+	// Also remove from selected IDs
+	selectedServerIds.update(($ids) => {
+		const newSet = new Set($ids);
+		newSet.delete(id);
+		return newSet;
+	});
+
+	refreshMcpServers();
+}
+
+/**
+ * Update server status (from health check)
+ */
+export function updateServerStatus(
+	id: string,
+	status: ServerStatus,
+	errorMessage?: string,
+	tools?: MCPTool[],
+	authRequired?: boolean
+) {
+	allMcpServers.update(($servers) =>
+		$servers.map((s) =>
+			s.id === id
+				? {
+						...s,
+						status,
+						errorMessage,
+						tools,
+						authRequired,
+					}
+				: s
+		)
+	);
+}
+
+/**
+ * Run health check on a server
+ */
+export async function healthCheckServer(
+	server: MCPServer
+): Promise<{ ready: boolean; tools?: MCPTool[]; error?: string }> {
+	try {
+		updateServerStatus(server.id, "connecting");
+
+		const response = await fetch(`${base}/api/mcp/health`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ url: server.url, headers: server.headers }),
+		});
+
+		const result = await response.json();
+
+		if (result.ready && result.tools) {
+			updateServerStatus(server.id, "connected", undefined, result.tools, false);
+			return { ready: true, tools: result.tools };
+		} else {
+			updateServerStatus(server.id, "error", result.error, undefined, Boolean(result.authRequired));
+			return { ready: false, error: result.error };
+		}
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : "Unknown error";
+		updateServerStatus(server.id, "error", errorMessage);
+		return { ready: false, error: errorMessage };
+	}
+}
+
+// Initialize on module load
+if (browser) {
+	refreshMcpServers();
+}

package/src/ruvocal/src/lib/stores/pendingChatInput.ts

@@ -0,0 +1,3 @@
+import { writable } from "svelte/store";
+
+export const pendingChatInput = writable<string | undefined>(undefined);

package/src/ruvocal/src/lib/stores/pendingMessage.ts

@@ -0,0 +1,9 @@
+import { writable } from "svelte/store";
+
+export const pendingMessage = writable<
+	| {
+			content: string;
+			files: File[];
+	  }
+	| undefined
+>();