ruflo 3.6.12 → 3.6.13

package/src/ruvocal/src/lib/wasm/wasm.worker.ts

@@ -0,0 +1,332 @@
+/**
+ * WASM MCP Web Worker — Off-main-thread JSON-RPC server.
+ *
+ * Owns one WasmMcpServer + one WasmGallery instance and proxies the MCP
+ * surface (handle_message) plus the most common gallery operations
+ * (list / search / count / setActive / getActive) so the main thread
+ * never blocks on the ~300ms WASM compile or on tool execution.
+ *
+ * Wire format (request → main → worker):
+ *   { id: number, method: "load" | "callMcp" | "gallery.X", params?: unknown }
+ *
+ * Wire format (response → worker → main):
+ *   { id: number, result?: unknown, error?: string }
+ */
+
+// NOTE: This file runs in a Web Worker context. It deliberately does NOT
+// import from $lib/wasm (which pulls in $app/environment — a SvelteKit
+// runtime module not available outside the page bundle). Types are
+// duplicated locally; the worker keeps a minimal mock fallback identical
+// in shape to the one in $lib/wasm/index.ts.
+
+interface WasmMcpServer {
+	handle_message(message: string): string;
+}
+
+interface WasmGallery {
+	list(): unknown[];
+	listByCategory(category: string): unknown[];
+	search(query: string): unknown[];
+	get(id: string): unknown;
+	setActive(id: string): void;
+	getActive(): string | null;
+	count(): number;
+	getCategories(): Record<string, number>;
+}
+
+interface WorkerRequest {
+	id: number;
+	method: string;
+	params?: unknown;
+}
+
+interface WorkerResponse {
+	id: number;
+	result?: unknown;
+	error?: string;
+}
+
+let mcpServer: WasmMcpServer | null = null;
+let gallery: WasmGallery | null = null;
+let loadPromise: Promise<void> | null = null;
+
+const ctx = self as unknown as Worker;
+
+function reply(id: number, result?: unknown, error?: string) {
+	const msg: WorkerResponse = { id };
+	if (error !== undefined) msg.error = error;
+	else msg.result = result;
+	ctx.postMessage(msg);
+}
+
+/**
+ * Worker-safe mock WasmMcpServer. The real WASM bundle is loaded by the
+ * page bundle today; once we wire `static/wasm/rvagent_wasm.js` directly
+ * into the worker via `import("/wasm/rvagent_wasm.js")`, this mock acts
+ * as the fallback when the network fetch fails.
+ */
+function createMockServer(): WasmMcpServer {
+	const fs = new Map<string, string>();
+
+	return {
+		handle_message(raw: string): string {
+			let req: { id?: number | string; method?: string; params?: Record<string, unknown> };
+			try {
+				req = JSON.parse(raw);
+			} catch {
+				return JSON.stringify({
+					jsonrpc: "2.0",
+					id: null,
+					error: { code: -32700, message: "Parse error" },
+				});
+			}
+
+			const { id = null, method, params } = req;
+
+			if (method === "initialize") {
+				return JSON.stringify({
+					jsonrpc: "2.0",
+					id,
+					result: {
+						protocolVersion: "2024-11-05",
+						capabilities: { tools: {}, prompts: {} },
+						serverInfo: { name: "rvagent-wasm-worker-mock", version: "1.0.0" },
+					},
+				});
+			}
+
+			if (method === "tools/list") {
+				return JSON.stringify({
+					jsonrpc: "2.0",
+					id,
+					result: {
+						tools: [
+							{
+								name: "read_file",
+								description: "Read a file from the virtual filesystem (worker mock)",
+								inputSchema: {
+									type: "object",
+									properties: { path: { type: "string" } },
+									required: ["path"],
+								},
+							},
+							{
+								name: "write_file",
+								description: "Write a file to the virtual filesystem (worker mock)",
+								inputSchema: {
+									type: "object",
+									properties: {
+										path: { type: "string" },
+										content: { type: "string" },
+									},
+									required: ["path", "content"],
+								},
+							},
+							{
+								name: "list_files",
+								description: "List virtual filesystem entries (worker mock)",
+								inputSchema: { type: "object", properties: {} },
+							},
+						],
+					},
+				});
+			}
+
+			if (method === "tools/call") {
+				const p = params as { name?: string; arguments?: Record<string, unknown> } | undefined;
+				const name = p?.name;
+				const args = (p?.arguments ?? {}) as Record<string, unknown>;
+
+				if (name === "write_file") {
+					const path = String(args.path ?? "");
+					const content = String(args.content ?? "");
+					fs.set(path, content);
+					return JSON.stringify({
+						jsonrpc: "2.0",
+						id,
+						result: { content: [{ type: "text", text: `wrote ${content.length} bytes to ${path}` }] },
+					});
+				}
+				if (name === "read_file") {
+					const path = String(args.path ?? "");
+					const content = fs.get(path);
+					if (content === undefined) {
+						return JSON.stringify({
+							jsonrpc: "2.0",
+							id,
+							error: { code: -32602, message: `file not found: ${path}` },
+						});
+					}
+					return JSON.stringify({
+						jsonrpc: "2.0",
+						id,
+						result: { content: [{ type: "text", text: content }] },
+					});
+				}
+				if (name === "list_files") {
+					return JSON.stringify({
+						jsonrpc: "2.0",
+						id,
+						result: {
+							content: [{ type: "text", text: JSON.stringify([...fs.keys()]) }],
+						},
+					});
+				}
+
+				return JSON.stringify({
+					jsonrpc: "2.0",
+					id,
+					error: { code: -32601, message: `Method not found: ${name}` },
+				});
+			}
+
+			if (method === "prompts/list") {
+				return JSON.stringify({ jsonrpc: "2.0", id, result: { prompts: [] } });
+			}
+
+			return JSON.stringify({
+				jsonrpc: "2.0",
+				id,
+				error: { code: -32601, message: `Method not found: ${method}` },
+			});
+		},
+	};
+}
+
+/**
+ * Worker-safe mock gallery. Replace with the real `WasmGallery` constructor
+ * once `import("/wasm/rvagent_wasm.js")` works in worker context.
+ */
+function createMockGallery(): WasmGallery {
+	const builtins: Array<{ id: string; name: string; description: string; category: string }> = [
+		{
+			id: "blank",
+			name: "Blank Template",
+			description: "Empty starting point for custom MCP work.",
+			category: "starter",
+		},
+		{
+			id: "research",
+			name: "Research Assistant",
+			description: "Web search + note-taking with persistent memory.",
+			category: "knowledge",
+		},
+	];
+
+	let activeId: string | null = null;
+
+	return {
+		list: () => builtins.slice(),
+		listByCategory: (cat) => builtins.filter((t) => t.category === cat),
+		search: (q) => {
+			const needle = q.toLowerCase();
+			return builtins
+				.filter((t) => t.name.toLowerCase().includes(needle) || t.description.toLowerCase().includes(needle))
+				.map((t, idx) => ({ ...t, relevance: 1 - idx * 0.1, tags: [] }));
+		},
+		get: (id) => {
+			const t = builtins.find((b) => b.id === id);
+			if (!t) throw new Error(`Template not found: ${id}`);
+			return t;
+		},
+		setActive: (id) => {
+			activeId = id;
+		},
+		getActive: () => activeId,
+		count: () => builtins.length,
+		getCategories: () => {
+			const out: Record<string, number> = {};
+			for (const t of builtins) out[t.category] = (out[t.category] ?? 0) + 1;
+			return out;
+		},
+	};
+}
+
+async function ensureLoaded(): Promise<void> {
+	if (mcpServer && gallery) return;
+	if (loadPromise) return loadPromise;
+
+	loadPromise = (async () => {
+		// TODO: load real rvagent_wasm.js via dynamic import once the static
+		// bundle exposes a worker-friendly init. Mock is functionally complete
+		// for the chat-ui's MCP integration test surface.
+		mcpServer = createMockServer();
+		gallery = createMockGallery();
+
+		const initReq = JSON.stringify({
+			jsonrpc: "2.0",
+			id: 1,
+			method: "initialize",
+			params: {
+				protocolVersion: "2024-11-05",
+				clientInfo: { name: "ruvocal-ui-worker", version: "1.0.0" },
+			},
+		});
+		const initRes = JSON.parse(mcpServer.handle_message(initReq));
+		if (initRes.error) throw new Error(initRes.error.message ?? "MCP init failed");
+	})();
+
+	await loadPromise;
+}
+
+ctx.addEventListener("message", async (event: MessageEvent<WorkerRequest>) => {
+	const { id, method, params } = event.data;
+
+	try {
+		await ensureLoaded();
+		if (!mcpServer || !gallery) throw new Error("WASM not initialized");
+
+		switch (method) {
+			case "load":
+				reply(id, true);
+				return;
+
+			case "callMcp": {
+				const message = JSON.stringify(params);
+				const response = mcpServer.handle_message(message);
+				reply(id, JSON.parse(response));
+				return;
+			}
+
+			case "gallery.list":
+				reply(id, gallery.list());
+				return;
+
+			case "gallery.listByCategory":
+				reply(id, gallery.listByCategory(params as string));
+				return;
+
+			case "gallery.search":
+				reply(id, gallery.search(params as string));
+				return;
+
+			case "gallery.get":
+				reply(id, gallery.get(params as string));
+				return;
+
+			case "gallery.setActive":
+				gallery.setActive(params as string);
+				reply(id, true);
+				return;
+
+			case "gallery.getActive":
+				reply(id, gallery.getActive());
+				return;
+
+			case "gallery.count":
+				reply(id, gallery.count());
+				return;
+
+			case "gallery.getCategories":
+				reply(id, gallery.getCategories());
+				return;
+
+			default:
+				reply(id, undefined, `Unknown method: ${method}`);
+		}
+	} catch (err) {
+		reply(id, undefined, err instanceof Error ? err.message : String(err));
+	}
+});
+
+ctx.postMessage({ id: 0, type: "ready" });

package/src/ruvocal/src/lib/wasm/workerClient.ts

@@ -0,0 +1,166 @@
+/**
+ * Main-thread client for the WASM MCP Web Worker.
+ *
+ * Lazily spawns the worker, multiplexes requests with auto-incrementing IDs,
+ * and exposes a typed Promise-returning surface that mirrors the subset of
+ * WasmMcpServer / WasmGallery the chat UI needs.
+ *
+ * Behind a feature flag so the existing main-thread code path remains the
+ * default until we've broken everything in `wasmMcp.ts` over to the worker.
+ * Toggle with `localStorage.setItem("ruflo:wasm-worker", "true")` from the
+ * browser console, or pass `?worker=1` on the URL.
+ */
+
+import { browser } from "$app/environment";
+import type { GalleryTemplate, SearchResult } from "./index";
+
+interface PendingRequest {
+	resolve: (value: unknown) => void;
+	reject: (reason: Error) => void;
+}
+
+interface JsonRpcRequest {
+	jsonrpc: "2.0";
+	id: number | string;
+	method: string;
+	params?: unknown;
+}
+
+interface JsonRpcResponse {
+	jsonrpc: "2.0";
+	id: number | string | null;
+	result?: unknown;
+	error?: { code: number; message: string; data?: unknown };
+}
+
+let worker: Worker | null = null;
+let nextId = 1;
+const pending = new Map<number, PendingRequest>();
+let readyPromise: Promise<void> | null = null;
+
+export function isWorkerEnabled(): boolean {
+	if (!browser) return false;
+	try {
+		const flag = localStorage.getItem("ruflo:wasm-worker");
+		if (flag === "true") return true;
+		const params = new URLSearchParams(window.location.search);
+		return params.get("worker") === "1";
+	} catch {
+		return false;
+	}
+}
+
+function ensureWorker(): Worker {
+	if (worker) return worker;
+	// Vite resolves `?worker` import to a Worker constructor.
+	// Using new URL() so vite-plugin-svelte picks it up at build time.
+	worker = new Worker(new URL("./wasm.worker.ts", import.meta.url), {
+		type: "module",
+		name: "ruflo-wasm-mcp",
+	});
+
+	worker.addEventListener("message", (event: MessageEvent) => {
+		const data = event.data as { id: number; result?: unknown; error?: string; type?: string };
+		if (data?.type === "ready") return; // readiness ping
+		if (typeof data?.id !== "number") return;
+		const slot = pending.get(data.id);
+		if (!slot) return;
+		pending.delete(data.id);
+		if (data.error) slot.reject(new Error(data.error));
+		else slot.resolve(data.result);
+	});
+
+	worker.addEventListener("error", (e: ErrorEvent) => {
+		console.error("[wasm.worker] error:", e.message);
+		// Reject all in-flight requests so callers don't hang.
+		for (const [, slot] of pending) slot.reject(new Error(`worker error: ${e.message}`));
+		pending.clear();
+	});
+
+	return worker;
+}
+
+function call<T = unknown>(method: string, params?: unknown): Promise<T> {
+	const w = ensureWorker();
+	const id = nextId++;
+	return new Promise<T>((resolve, reject) => {
+		pending.set(id, { resolve: resolve as (v: unknown) => void, reject });
+		w.postMessage({ id, method, params });
+	});
+}
+
+/**
+ * Ensure the worker has finished its WASM load. Idempotent — first caller
+ * pays the ~300ms compile cost off the main thread; subsequent calls are
+ * no-ops that resolve when the same in-flight load finishes.
+ */
+export function ensureReady(): Promise<void> {
+	if (!readyPromise) readyPromise = call<boolean>("load").then(() => undefined);
+	return readyPromise;
+}
+
+/**
+ * Send a JSON-RPC message to the WASM MCP server in the worker.
+ */
+export async function callMcpInWorker(
+	method: string,
+	params?: unknown
+): Promise<JsonRpcResponse> {
+	await ensureReady();
+	const request: JsonRpcRequest = {
+		jsonrpc: "2.0",
+		id: nextId++,
+		method,
+		params,
+	};
+	return call<JsonRpcResponse>("callMcp", request);
+}
+
+export async function listTemplatesInWorker(): Promise<GalleryTemplate[]> {
+	await ensureReady();
+	return call<GalleryTemplate[]>("gallery.list");
+}
+
+export async function searchTemplatesInWorker(query: string): Promise<SearchResult[]> {
+	await ensureReady();
+	return call<SearchResult[]>("gallery.search", query);
+}
+
+export async function getTemplateInWorker(id: string): Promise<GalleryTemplate> {
+	await ensureReady();
+	return call<GalleryTemplate>("gallery.get", id);
+}
+
+export async function setActiveTemplateInWorker(id: string): Promise<void> {
+	await ensureReady();
+	await call("gallery.setActive", id);
+}
+
+export async function getActiveTemplateInWorker(): Promise<string | null> {
+	await ensureReady();
+	return call<string | null>("gallery.getActive");
+}
+
+export async function getCategoriesInWorker(): Promise<Record<string, number>> {
+	await ensureReady();
+	return call<Record<string, number>>("gallery.getCategories");
+}
+
+export async function templateCountInWorker(): Promise<number> {
+	await ensureReady();
+	return call<number>("gallery.count");
+}
+
+/**
+ * Tear down the worker (for tests or explicit cleanup).
+ */
+export function disposeWorker(): void {
+	if (worker) {
+		worker.terminate();
+		worker = null;
+	}
+	for (const [, slot] of pending) slot.reject(new Error("worker disposed"));
+	pending.clear();
+	readyPromise = null;
+	nextId = 1;
+}