ruflo 3.5.2 → 3.5.3

package/src/ruvocal/src/lib/utils/haptics.ts

@@ -0,0 +1,64 @@
+import { browser } from "$app/environment";
+import type { WebHaptics } from "web-haptics";
+
+let instance: WebHaptics | null = null;
+let enabled = true;
+
+/**
+ * Lazily initializes the WebHaptics instance on first use.
+ * Avoids importing at module level so SSR doesn't break.
+ */
+async function getInstance(): Promise<WebHaptics | null> {
+	if (!browser || !supportsHaptics()) return null;
+	if (instance) return instance;
+
+	try {
+		const { WebHaptics: WH } = await import("web-haptics");
+		instance = new WH();
+		return instance;
+	} catch {
+		return null;
+	}
+}
+
+/** Call from the settings store to keep haptics in sync with user preference. */
+export function setHapticsEnabled(value: boolean) {
+	enabled = value;
+}
+
+/** Whether the device likely supports haptic feedback (touch screen present). */
+export function supportsHaptics(): boolean {
+	return browser && navigator.maxTouchPoints > 0;
+}
+
+// ── Internals ────────────────────────────────────────────────────────
+
+/** Fire a haptic pattern, swallowing errors so callers can safely fire-and-forget. */
+function fire(pattern: string): void {
+	if (!enabled) return;
+	Promise.resolve(getInstance())
+		.then((h) => h?.trigger(pattern))
+		.catch(() => {});
+}
+
+// ── Semantic haptic actions ──────────────────────────────────────────
+
+/** Light tap — for routine actions (send message, toggle, navigate). */
+export function tap() {
+	fire("light");
+}
+
+/** Success confirmation — double-tap pattern (copy, share, save). */
+export function confirm() {
+	fire("success");
+}
+
+/** Error / destructive warning — three rapid taps (delete, stop generation). */
+export function error() {
+	fire("error");
+}
+
+/** Selection change — subtle tap for pickers and selections. */
+export function selection() {
+	fire("selection");
+}

package/src/ruvocal/src/lib/utils/hashConv.ts

@@ -0,0 +1,12 @@
+import type { Conversation } from "$lib/types/Conversation";
+import { sha256 } from "./sha256";
+
+export async function hashConv(conv: Conversation) {
+	// messages contains the conversation message but only the immutable part
+	const messages = conv.messages.map((message) => {
+		return (({ from, id, content }) => ({ from, id, content }))(message);
+	});
+
+	const hash = await sha256(JSON.stringify(messages));
+	return hash;
+}

package/src/ruvocal/src/lib/utils/hf.ts

@@ -0,0 +1,17 @@
+// Client-safe HF utilities used in UI components
+
+export function isStrictHfMcpLogin(urlString: string): boolean {
+	try {
+		const u = new URL(urlString);
+		const host = u.hostname.toLowerCase();
+		const allowedHosts = new Set(["hf.co", "huggingface.co"]);
+		return (
+			u.protocol === "https:" &&
+			allowedHosts.has(host) &&
+			u.pathname === "/mcp" &&
+			u.search === "?login"
+		);
+	} catch {
+		return false;
+	}
+}

package/src/ruvocal/src/lib/utils/isDesktop.ts

@@ -0,0 +1,7 @@
+// Approximate width from which we disable autofocus
+const TABLET_VIEWPORT_WIDTH = 768;
+
+export function isDesktop(window: Window) {
+	const { innerWidth } = window;
+	return innerWidth > TABLET_VIEWPORT_WIDTH;
+}

package/src/ruvocal/src/lib/utils/isUrl.ts

@@ -0,0 +1,8 @@
+export function isURL(url: string) {
+	try {
+		new URL(url);
+		return true;
+	} catch (e) {
+		return false;
+	}
+}

package/src/ruvocal/src/lib/utils/isVirtualKeyboard.ts

@@ -0,0 +1,16 @@
+import { browser } from "$app/environment";
+
+export function isVirtualKeyboard(): boolean {
+	if (!browser) return false;
+
+	// Check for touch capability
+	if (navigator.maxTouchPoints > 0 && screen.width <= 768) return true;
+
+	// Check for touch events
+	if ("ontouchstart" in window) return true;
+
+	// Fallback to user agent string check
+	const userAgent = navigator.userAgent.toLowerCase();
+
+	return /android|webos|iphone|ipad|ipod|blackberry|iemobile|opera mini/i.test(userAgent);
+}

package/src/ruvocal/src/lib/utils/loadAttachmentsFromUrls.ts

@@ -0,0 +1,115 @@
+import { base } from "$app/paths";
+import { pickSafeMime } from "$lib/utils/mime";
+
+export interface AttachmentLoadResult {
+	files: File[];
+	errors: string[];
+}
+
+/**
+ * Parse attachment URLs from query parameters
+ * Supports both comma-separated (?attachments=url1,url2) and multiple params (?attachments=url1&attachments=url2)
+ */
+function parseAttachmentUrls(searchParams: URLSearchParams): string[] {
+	const urls: string[] = [];
+
+	// Get all 'attachments' parameters
+	const attachmentParams = searchParams.getAll("attachments");
+
+	for (const param of attachmentParams) {
+		// Split by comma in case multiple URLs are in one param
+		const splitUrls = param.split(",").map((url) => url.trim());
+		urls.push(...splitUrls);
+	}
+
+	// Filter out empty strings
+	return urls.filter((url) => url.length > 0);
+}
+
+/**
+ * Extract filename from URL or Content-Disposition header
+ */
+function extractFilename(url: string, contentDisposition?: string | null): string {
+	// Try to get filename from Content-Disposition header
+	if (contentDisposition) {
+		const filenameStar = contentDisposition.match(/filename\*=UTF-8''([^;]+)/i)?.[1];
+		if (filenameStar) {
+			const cleaned = filenameStar.trim().replace(/['"]/g, "");
+			try {
+				return decodeURIComponent(cleaned);
+			} catch {
+				return cleaned;
+			}
+		}
+
+		const match = contentDisposition.match(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/);
+		if (match && match[1]) return match[1].replace(/['"]/g, "");
+	}
+
+	// Fallback: extract from URL
+	try {
+		const urlObj = new URL(url);
+		const pathname = urlObj.pathname;
+		const segments = pathname.split("/");
+		const lastSegment = segments[segments.length - 1];
+
+		if (lastSegment && lastSegment.length > 0) {
+			return decodeURIComponent(lastSegment);
+		}
+	} catch {
+		// Invalid URL, fall through to default
+	}
+
+	return "attachment";
+}
+
+/**
+ * Load files from remote URLs via server-side proxy
+ */
+export async function loadAttachmentsFromUrls(
+	searchParams: URLSearchParams
+): Promise<AttachmentLoadResult> {
+	const urls = parseAttachmentUrls(searchParams);
+
+	if (urls.length === 0) {
+		return { files: [], errors: [] };
+	}
+
+	const files: File[] = [];
+	const errors: string[] = [];
+
+	await Promise.all(
+		urls.map(async (url) => {
+			try {
+				// Fetch via our proxy endpoint to bypass CORS
+				const proxyUrl = `${base}/api/fetch-url?${new URLSearchParams({ url })}`;
+				const response = await fetch(proxyUrl);
+
+				if (!response.ok) {
+					const errorText = await response.text();
+					errors.push(`Failed to fetch ${url}: ${errorText}`);
+					return;
+				}
+
+				const forwardedType = response.headers.get("x-forwarded-content-type");
+				const blob = await response.blob();
+				const mimeType = pickSafeMime(forwardedType, blob.type, url);
+				const contentDisposition = response.headers.get("content-disposition");
+				const filename = extractFilename(url, contentDisposition);
+
+				// Create File object
+				const file = new File([blob], filename, {
+					type: mimeType,
+				});
+
+				files.push(file);
+			} catch (err) {
+				const message = err instanceof Error ? err.message : "Unknown error";
+				errors.push(`Failed to load ${url}: ${message}`);
+				console.error(`Error loading attachment from ${url}:`, err);
+			}
+		})
+	);
+
+	return { files, errors };
+}

package/src/ruvocal/src/lib/utils/marked.spec.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from "vitest";
+import { processTokensSync } from "./marked";
+
+function renderHtml(md: string): string {
+	const tokens = processTokensSync(md, []);
+	const textToken = tokens.find((token) => token.type === "text");
+	if (!textToken || textToken.type !== "text") return "";
+	return typeof textToken.html === "string" ? textToken.html : "";
+}
+
+describe("marked basic rendering", () => {
+	test("renders bold text", () => {
+		const html = renderHtml("**bold**");
+		expect(html).toContain("<strong>bold</strong>");
+	});
+
+	test("renders links", () => {
+		const html = renderHtml("[link](https://example.com)");
+		expect(html).toContain('<a href="https://example.com"');
+		expect(html).toContain("link</a>");
+	});
+
+	test("renders paragraphs", () => {
+		const html = renderHtml("hello world");
+		expect(html).toContain("<p>hello world</p>");
+	});
+});
+
+describe("marked image renderer", () => {
+	test("renders video extensions as <video>", () => {
+		const html = renderHtml("![](https://example.com/clip.mp4)");
+		expect(html).toContain("<video controls");
+		expect(html).toContain('<source src="https://example.com/clip.mp4">');
+	});
+
+	test("renders audio extensions as <audio>", () => {
+		const html = renderHtml("![](https://example.com/clip.mp3)");
+		expect(html).toContain("<audio controls");
+		expect(html).toContain('<source src="https://example.com/clip.mp3">');
+	});
+
+	test("renders non-video images as <img>", () => {
+		const html = renderHtml("![](https://example.com/pic.png)");
+		expect(html).toContain('<img src="https://example.com/pic.png"');
+	});
+
+	test("renders video with query params", () => {
+		const html = renderHtml("![](https://example.com/clip.mp4?token=abc)");
+		expect(html).toContain("<video controls");
+		expect(html).toContain("clip.mp4?token=abc");
+	});
+});
+
+describe("marked html video tag support", () => {
+	test("allows raw <video> tags with controls", () => {
+		const html = renderHtml('<video controls src="https://example.com/video.mp4"></video>');
+		expect(html).toContain("<video");
+		expect(html).toContain("controls");
+		expect(html).toContain('src="https://example.com/video.mp4"');
+	});
+
+	test("allows <video> with nested <source> tags", () => {
+		const html = renderHtml(
+			'<video controls><source src="https://example.com/video.webm" type="video/webm"></video>'
+		);
+		expect(html).toContain("<video");
+		expect(html).toContain("<source");
+		expect(html).toContain('src="https://example.com/video.webm"');
+	});
+
+	test("strips disallowed attributes from video tags", () => {
+		const html = renderHtml('<video onclick="alert(1)" src="https://example.com/v.mp4"></video>');
+		expect(html).toContain("<video");
+		expect(html).not.toContain("onclick");
+	});
+
+	test("strips javascript: URLs from media sources", () => {
+		const html = renderHtml('<video controls src="javascript:alert(1)"></video>');
+		expect(html).not.toContain("javascript:");
+	});
+
+	test("escapes disallowed html tags", () => {
+		const html = renderHtml("<script>alert(1)</script>");
+		expect(html).not.toContain("<script>");
+		expect(html).toContain("&lt;script&gt;");
+	});
+
+	test("allows <audio> tags with controls", () => {
+		const html = renderHtml(
+			'<audio controls><source src="https://example.com/audio.mp3" type="audio/mpeg"></audio>'
+		);
+		expect(html).toContain("<audio");
+		expect(html).toContain("<source");
+		expect(html).toContain('type="audio/mpeg"');
+	});
+});