ruflo 3.10.45 → 3.11.0

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

@@ -1,74 +1,74 @@
-import { Address6, Address4 } from "ip-address";
-import dns from "node:dns";
-import { isIP } from "node:net";
-
-const dnsLookup = (hostname: string): Promise<{ address: string; family: number }> => {
-	return new Promise((resolve, reject) => {
-		dns.lookup(hostname, (err, address, family) => {
-			if (err) return reject(err);
-			resolve({ address, family });
-		});
-	});
-};
-
-function assertValidHostname(hostname: string): void {
-	if (!hostname || hostname.length > 253) {
-		throw new Error("Invalid hostname");
-	}
-
-	const labels = hostname.split(".");
-
-	for (const label of labels) {
-		if (!label || label.length > 63) {
-			throw new Error("Invalid hostname");
-		}
-
-		if (!/^[A-Za-z0-9-]+$/.test(label)) {
-			throw new Error("Invalid hostname");
-		}
-
-		if (label.startsWith("-") || label.endsWith("-")) {
-			throw new Error("Invalid hostname");
-		}
-	}
-}
-
-export async function isURLLocal(URL: URL): Promise<boolean> {
-	if (!isIP(URL.hostname)) {
-		assertValidHostname(URL.hostname);
-	}
-
-	const { address, family } = await dnsLookup(URL.hostname);
-
-	if (family === 4) {
-		const addr = new Address4(address);
-		const localSubnet = new Address4("127.0.0.0/8");
-		return addr.isInSubnet(localSubnet);
-	}
-
-	if (family === 6) {
-		const addr = new Address6(address);
-		return addr.isLoopback() || addr.isInSubnet(new Address6("::1/128")) || addr.isLinkLocal();
-	}
-
-	throw Error("Unknown IP family");
-}
-
-export function isURLStringLocal(url: string) {
-	try {
-		const urlObj = new URL(url);
-		return isURLLocal(urlObj);
-	} catch (e) {
-		// assume local if URL parsing fails
-		return true;
-	}
-}
-
-export function isHostLocalhost(host: string): boolean {
-	if (host === "localhost") return true;
-	if (host === "::1" || host === "[::1]") return true;
-	if (host.startsWith("127.") && isIP(host)) return true;
-	if (host.endsWith(".localhost")) return true;
-
-	return false;
-}
+import { Address6, Address4 } from "ip-address";
+import dns from "node:dns";
+import { isIP } from "node:net";
+
+const dnsLookup = (hostname: string): Promise<{ address: string; family: number }> => {
+	return new Promise((resolve, reject) => {
+		dns.lookup(hostname, (err, address, family) => {
+			if (err) return reject(err);
+			resolve({ address, family });
+		});
+	});
+};
+
+function assertValidHostname(hostname: string): void {
+	if (!hostname || hostname.length > 253) {
+		throw new Error("Invalid hostname");
+	}
+
+	const labels = hostname.split(".");
+
+	for (const label of labels) {
+		if (!label || label.length > 63) {
+			throw new Error("Invalid hostname");
+		}
+
+		if (!/^[A-Za-z0-9-]+$/.test(label)) {
+			throw new Error("Invalid hostname");
+		}
+
+		if (label.startsWith("-") || label.endsWith("-")) {
+			throw new Error("Invalid hostname");
+		}
+	}
+}
+
+export async function isURLLocal(URL: URL): Promise<boolean> {
+	if (!isIP(URL.hostname)) {
+		assertValidHostname(URL.hostname);
+	}
+
+	const { address, family } = await dnsLookup(URL.hostname);
+
+	if (family === 4) {
+		const addr = new Address4(address);
+		const localSubnet = new Address4("127.0.0.0/8");
+		return addr.isInSubnet(localSubnet);
+	}
+
+	if (family === 6) {
+		const addr = new Address6(address);
+		return addr.isLoopback() || addr.isInSubnet(new Address6("::1/128")) || addr.isLinkLocal();
+	}
+
+	throw Error("Unknown IP family");
+}
+
+export function isURLStringLocal(url: string) {
+	try {
+		const urlObj = new URL(url);
+		return isURLLocal(urlObj);
+	} catch (e) {
+		// assume local if URL parsing fails
+		return true;
+	}
+}
+
+export function isHostLocalhost(host: string): boolean {
+	if (host === "localhost") return true;
+	if (host === "::1" || host === "[::1]") return true;
+	if (host.startsWith("127.") && isIP(host)) return true;
+	if (host.endsWith(".localhost")) return true;
+
+	return false;
+}

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

@@ -1,42 +1,42 @@
-import pino from "pino";
-import { dev } from "$app/environment";
-import { config } from "$lib/server/config";
-import { getRequestContext } from "$lib/server/requestContext";
-
-let options: pino.LoggerOptions = {};
-
-if (dev) {
-	options = {
-		transport: {
-			target: "pino-pretty",
-			options: {
-				colorize: true,
-			},
-		},
-	};
-}
-
-const baseLogger = pino({
-	...options,
-	messageKey: "message",
-	level: config.LOG_LEVEL || "info",
-	formatters: {
-		level: (label) => {
-			return { level: label };
-		},
-	},
-	mixin() {
-		const ctx = getRequestContext();
-		if (!ctx) return {};
-
-		const result: Record<string, string | number> = {};
-		if (ctx.requestId) result.request_id = ctx.requestId;
-		if (ctx.url) result.url = ctx.url;
-		if (ctx.ip) result.ip = ctx.ip;
-		if (ctx.user) result.user = ctx.user;
-		if (ctx.statusCode) result.status_code = ctx.statusCode;
-		return result;
-	},
-});
-
-export const logger = baseLogger;
+import pino from "pino";
+import { dev } from "$app/environment";
+import { config } from "$lib/server/config";
+import { getRequestContext } from "$lib/server/requestContext";
+
+let options: pino.LoggerOptions = {};
+
+if (dev) {
+	options = {
+		transport: {
+			target: "pino-pretty",
+			options: {
+				colorize: true,
+			},
+		},
+	};
+}
+
+const baseLogger = pino({
+	...options,
+	messageKey: "message",
+	level: config.LOG_LEVEL || "info",
+	formatters: {
+		level: (label) => {
+			return { level: label };
+		},
+	},
+	mixin() {
+		const ctx = getRequestContext();
+		if (!ctx) return {};
+
+		const result: Record<string, string | number> = {};
+		if (ctx.requestId) result.request_id = ctx.requestId;
+		if (ctx.url) result.url = ctx.url;
+		if (ctx.ip) result.ip = ctx.ip;
+		if (ctx.user) result.user = ctx.user;
+		if (ctx.statusCode) result.status_code = ctx.statusCode;
+		return result;
+	},
+});
+
+export const logger = baseLogger;

package/src/ruvocal/src/lib/server/mcp/clientPool.spec.ts

@@ -1,175 +1,175 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { StreamableHTTPError } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-
-// We mock the MCP SDK transports + Client so we can drive the connection
-// outcomes deterministically. The point of these tests is to verify that
-// clientPool.ts:
-//   1. Skips the SSE fallback when the first transport returns 4xx/5xx (e.g. 429)
-//      because retrying via SSE will hit the same upstream and produce the
-//      same rate-limit response.
-//   2. Surfaces a typed McpRateLimitedError on 429 with retryAfterMs derived
-//      from the upstream Retry-After header when present.
-//   3. Memoizes the failure for a cooldown window so subsequent getClient
-//      calls don't pound the upstream.
-//   4. Still falls back to SSE for transport-level / network errors that
-//      have no HTTP status (the "Streamable HTTP server is not running" path).
-
-const httpConnectMock = vi.fn();
-const sseConnectMock = vi.fn();
-
-vi.mock("@modelcontextprotocol/sdk/client", () => {
-	class MockClient {
-		private nextTransportIsHttp = true;
-		async connect(transport: unknown) {
-			// The transport instances are tagged below in the streamableHttp/sse mocks.
-			const isHttp = (transport as { __kind?: string }).__kind === "http";
-			if (isHttp) {
-				return httpConnectMock();
-			}
-			return sseConnectMock();
-		}
-		async close() {}
-		async callTool() {
-			return { content: [] };
-		}
-	}
-	return { Client: MockClient };
-});
-
-vi.mock("@modelcontextprotocol/sdk/client/streamableHttp.js", () => {
-	class StreamableHTTPError extends Error {
-		code: number;
-		constructor(code: number, message: string) {
-			super(`Streamable HTTP error: ${message}`);
-			this.code = code;
-			this.name = "StreamableHTTPError";
-		}
-	}
-	class StreamableHTTPClientTransport {
-		__kind = "http";
-		constructor(_url: URL, _opts: unknown) {}
-	}
-	return { StreamableHTTPError, StreamableHTTPClientTransport };
-});
-
-vi.mock("@modelcontextprotocol/sdk/client/sse.js", () => {
-	class SSEClientTransport {
-		__kind = "sse";
-		constructor(_url: URL, _opts: unknown) {}
-	}
-	return { SSEClientTransport };
-});
-
-// Import AFTER vi.mock declarations.
-import { getClient, drainPool, McpRateLimitedError } from "./clientPool";
-
-const server = { name: "test-server", url: "https://example.test/mcp", headers: {} };
-
-describe("clientPool — rate-limit and HTTP error handling", () => {
-	beforeEach(async () => {
-		await drainPool();
-		httpConnectMock.mockReset();
-		sseConnectMock.mockReset();
-	});
-
-	afterEach(async () => {
-		await drainPool();
-	});
-
-	it("skips SSE fallback on 429 and throws McpRateLimitedError", async () => {
-		httpConnectMock.mockRejectedValue(
-			new StreamableHTTPError(
-				429,
-				"Error POSTing to endpoint: Rate exceeded. Retry-After: 7"
-			)
-		);
-
-		await expect(getClient(server)).rejects.toBeInstanceOf(McpRateLimitedError);
-		// Critical: SSE was NOT attempted — would just hit the same upstream.
-		expect(sseConnectMock).not.toHaveBeenCalled();
-		expect(httpConnectMock).toHaveBeenCalledTimes(1);
-	});
-
-	it("honors Retry-After when present in the error message", async () => {
-		httpConnectMock.mockRejectedValue(
-			new StreamableHTTPError(
-				429,
-				"Error POSTing to endpoint: Rate exceeded. Retry-After: 12"
-			)
-		);
-
-		try {
-			await getClient(server);
-			throw new Error("should have thrown");
-		} catch (err) {
-			expect(err).toBeInstanceOf(McpRateLimitedError);
-			expect((err as McpRateLimitedError).retryAfterMs).toBe(12_000);
-			expect((err as McpRateLimitedError).status).toBe(429);
-			expect((err as McpRateLimitedError).serverName).toBe("test-server");
-		}
-	});
-
-	it("memoizes the 429 failure and skips network on subsequent calls during cooldown", async () => {
-		httpConnectMock.mockRejectedValue(
-			new StreamableHTTPError(429, "Error POSTing to endpoint: Rate exceeded. Retry-After: 5")
-		);
-
-		await expect(getClient(server)).rejects.toBeInstanceOf(McpRateLimitedError);
-		// Second call within the cooldown window: must NOT touch the upstream again.
-		await expect(getClient(server)).rejects.toBeInstanceOf(McpRateLimitedError);
-		expect(httpConnectMock).toHaveBeenCalledTimes(1);
-		expect(sseConnectMock).not.toHaveBeenCalled();
-	});
-
-	it("skips SSE fallback on 4xx (e.g. 401)", async () => {
-		httpConnectMock.mockRejectedValue(
-			new StreamableHTTPError(401, "Unauthorized")
-		);
-		await expect(getClient(server)).rejects.toThrow(/HTTP 401/);
-		expect(sseConnectMock).not.toHaveBeenCalled();
-	});
-
-	it("skips SSE fallback on 5xx (e.g. 503)", async () => {
-		httpConnectMock.mockRejectedValue(
-			new StreamableHTTPError(503, "Service Unavailable")
-		);
-		await expect(getClient(server)).rejects.toThrow(/HTTP 503/);
-		expect(sseConnectMock).not.toHaveBeenCalled();
-	});
-
-	it("falls back to SSE on transport-level / network errors with no HTTP status", async () => {
-		httpConnectMock.mockRejectedValue(new Error("ECONNREFUSED"));
-		sseConnectMock.mockResolvedValue(undefined);
-
-		const client = await getClient(server);
-		expect(client).toBeDefined();
-		expect(httpConnectMock).toHaveBeenCalledTimes(1);
-		expect(sseConnectMock).toHaveBeenCalledTimes(1);
-	});
-
-	it("falls back to SSE on 408 Request Timeout (recoverable)", async () => {
-		httpConnectMock.mockRejectedValue(
-			new StreamableHTTPError(408, "Request Timeout")
-		);
-		sseConnectMock.mockResolvedValue(undefined);
-
-		const client = await getClient(server);
-		expect(client).toBeDefined();
-		expect(sseConnectMock).toHaveBeenCalledTimes(1);
-	});
-
-	it("surfaces 429 even when the SSE fallback also reports 429", async () => {
-		httpConnectMock.mockRejectedValue(new Error("transport mismatch")); // forces SSE attempt
-		sseConnectMock.mockRejectedValue(
-			new Error("SSE error: Non-200 status code (429)")
-		);
-
-		try {
-			await getClient(server);
-			throw new Error("should have thrown");
-		} catch (err) {
-			expect(err).toBeInstanceOf(McpRateLimitedError);
-			expect((err as McpRateLimitedError).status).toBe(429);
-		}
-	});
-});
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { StreamableHTTPError } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+// We mock the MCP SDK transports + Client so we can drive the connection
+// outcomes deterministically. The point of these tests is to verify that
+// clientPool.ts:
+//   1. Skips the SSE fallback when the first transport returns 4xx/5xx (e.g. 429)
+//      because retrying via SSE will hit the same upstream and produce the
+//      same rate-limit response.
+//   2. Surfaces a typed McpRateLimitedError on 429 with retryAfterMs derived
+//      from the upstream Retry-After header when present.
+//   3. Memoizes the failure for a cooldown window so subsequent getClient
+//      calls don't pound the upstream.
+//   4. Still falls back to SSE for transport-level / network errors that
+//      have no HTTP status (the "Streamable HTTP server is not running" path).
+
+const httpConnectMock = vi.fn();
+const sseConnectMock = vi.fn();
+
+vi.mock("@modelcontextprotocol/sdk/client", () => {
+	class MockClient {
+		private nextTransportIsHttp = true;
+		async connect(transport: unknown) {
+			// The transport instances are tagged below in the streamableHttp/sse mocks.
+			const isHttp = (transport as { __kind?: string }).__kind === "http";
+			if (isHttp) {
+				return httpConnectMock();
+			}
+			return sseConnectMock();
+		}
+		async close() {}
+		async callTool() {
+			return { content: [] };
+		}
+	}
+	return { Client: MockClient };
+});
+
+vi.mock("@modelcontextprotocol/sdk/client/streamableHttp.js", () => {
+	class StreamableHTTPError extends Error {
+		code: number;
+		constructor(code: number, message: string) {
+			super(`Streamable HTTP error: ${message}`);
+			this.code = code;
+			this.name = "StreamableHTTPError";
+		}
+	}
+	class StreamableHTTPClientTransport {
+		__kind = "http";
+		constructor(_url: URL, _opts: unknown) {}
+	}
+	return { StreamableHTTPError, StreamableHTTPClientTransport };
+});
+
+vi.mock("@modelcontextprotocol/sdk/client/sse.js", () => {
+	class SSEClientTransport {
+		__kind = "sse";
+		constructor(_url: URL, _opts: unknown) {}
+	}
+	return { SSEClientTransport };
+});
+
+// Import AFTER vi.mock declarations.
+import { getClient, drainPool, McpRateLimitedError } from "./clientPool";
+
+const server = { name: "test-server", url: "https://example.test/mcp", headers: {} };
+
+describe("clientPool — rate-limit and HTTP error handling", () => {
+	beforeEach(async () => {
+		await drainPool();
+		httpConnectMock.mockReset();
+		sseConnectMock.mockReset();
+	});
+
+	afterEach(async () => {
+		await drainPool();
+	});
+
+	it("skips SSE fallback on 429 and throws McpRateLimitedError", async () => {
+		httpConnectMock.mockRejectedValue(
+			new StreamableHTTPError(
+				429,
+				"Error POSTing to endpoint: Rate exceeded. Retry-After: 7"
+			)
+		);
+
+		await expect(getClient(server)).rejects.toBeInstanceOf(McpRateLimitedError);
+		// Critical: SSE was NOT attempted — would just hit the same upstream.
+		expect(sseConnectMock).not.toHaveBeenCalled();
+		expect(httpConnectMock).toHaveBeenCalledTimes(1);
+	});
+
+	it("honors Retry-After when present in the error message", async () => {
+		httpConnectMock.mockRejectedValue(
+			new StreamableHTTPError(
+				429,
+				"Error POSTing to endpoint: Rate exceeded. Retry-After: 12"
+			)
+		);
+
+		try {
+			await getClient(server);
+			throw new Error("should have thrown");
+		} catch (err) {
+			expect(err).toBeInstanceOf(McpRateLimitedError);
+			expect((err as McpRateLimitedError).retryAfterMs).toBe(12_000);
+			expect((err as McpRateLimitedError).status).toBe(429);
+			expect((err as McpRateLimitedError).serverName).toBe("test-server");
+		}
+	});
+
+	it("memoizes the 429 failure and skips network on subsequent calls during cooldown", async () => {
+		httpConnectMock.mockRejectedValue(
+			new StreamableHTTPError(429, "Error POSTing to endpoint: Rate exceeded. Retry-After: 5")
+		);
+
+		await expect(getClient(server)).rejects.toBeInstanceOf(McpRateLimitedError);
+		// Second call within the cooldown window: must NOT touch the upstream again.
+		await expect(getClient(server)).rejects.toBeInstanceOf(McpRateLimitedError);
+		expect(httpConnectMock).toHaveBeenCalledTimes(1);
+		expect(sseConnectMock).not.toHaveBeenCalled();
+	});
+
+	it("skips SSE fallback on 4xx (e.g. 401)", async () => {
+		httpConnectMock.mockRejectedValue(
+			new StreamableHTTPError(401, "Unauthorized")
+		);
+		await expect(getClient(server)).rejects.toThrow(/HTTP 401/);
+		expect(sseConnectMock).not.toHaveBeenCalled();
+	});
+
+	it("skips SSE fallback on 5xx (e.g. 503)", async () => {
+		httpConnectMock.mockRejectedValue(
+			new StreamableHTTPError(503, "Service Unavailable")
+		);
+		await expect(getClient(server)).rejects.toThrow(/HTTP 503/);
+		expect(sseConnectMock).not.toHaveBeenCalled();
+	});
+
+	it("falls back to SSE on transport-level / network errors with no HTTP status", async () => {
+		httpConnectMock.mockRejectedValue(new Error("ECONNREFUSED"));
+		sseConnectMock.mockResolvedValue(undefined);
+
+		const client = await getClient(server);
+		expect(client).toBeDefined();
+		expect(httpConnectMock).toHaveBeenCalledTimes(1);
+		expect(sseConnectMock).toHaveBeenCalledTimes(1);
+	});
+
+	it("falls back to SSE on 408 Request Timeout (recoverable)", async () => {
+		httpConnectMock.mockRejectedValue(
+			new StreamableHTTPError(408, "Request Timeout")
+		);
+		sseConnectMock.mockResolvedValue(undefined);
+
+		const client = await getClient(server);
+		expect(client).toBeDefined();
+		expect(sseConnectMock).toHaveBeenCalledTimes(1);
+	});
+
+	it("surfaces 429 even when the SSE fallback also reports 429", async () => {
+		httpConnectMock.mockRejectedValue(new Error("transport mismatch")); // forces SSE attempt
+		sseConnectMock.mockRejectedValue(
+			new Error("SSE error: Non-200 status code (429)")
+		);
+
+		try {
+			await getClient(server);
+			throw new Error("should have thrown");
+		} catch (err) {
+			expect(err).toBeInstanceOf(McpRateLimitedError);
+			expect((err as McpRateLimitedError).status).toBe(429);
+		}
+	});
+});

package/src/ruvocal/src/lib/server/mcp/hf.ts

@@ -1,32 +1,32 @@
-// Minimal shared helpers for HF MCP token forwarding
-
-export const hasAuthHeader = (h?: Record<string, string>) =>
-	!!h && Object.keys(h).some((k) => k.toLowerCase() === "authorization");
-
-export const isStrictHfMcpLogin = (urlString: string) => {
-	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;
-	}
-};
-
-export const hasNonEmptyToken = (tok: unknown): tok is string =>
-	typeof tok === "string" && tok.trim().length > 0;
-
-export const isExaMcpServer = (urlString: string): boolean => {
-	try {
-		const u = new URL(urlString);
-		return u.protocol === "https:" && u.hostname.toLowerCase() === "mcp.exa.ai";
-	} catch {
-		return false;
-	}
-};
+// Minimal shared helpers for HF MCP token forwarding
+
+export const hasAuthHeader = (h?: Record<string, string>) =>
+	!!h && Object.keys(h).some((k) => k.toLowerCase() === "authorization");
+
+export const isStrictHfMcpLogin = (urlString: string) => {
+	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;
+	}
+};
+
+export const hasNonEmptyToken = (tok: unknown): tok is string =>
+	typeof tok === "string" && tok.trim().length > 0;
+
+export const isExaMcpServer = (urlString: string): boolean => {
+	try {
+		const u = new URL(urlString);
+		return u.protocol === "https:" && u.hostname.toLowerCase() === "mcp.exa.ai";
+	} catch {
+		return false;
+	}
+};