ruflo 3.42.1 → 3.42.3

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

@@ -1,122 +1,122 @@
-import { Client } from "@modelcontextprotocol/sdk/client";
-import { getClient, evictFromPool } from "./clientPool";
-import { config } from "$lib/server/config";
-
-function isConnectionClosedError(err: unknown): boolean {
-	const message = err instanceof Error ? err.message : String(err);
-	return message.includes("-32000") || message.toLowerCase().includes("connection closed");
-}
-
-export interface McpServerConfig {
-	name: string;
-	url: string;
-	headers?: Record<string, string>;
-}
-
-const DEFAULT_TIMEOUT_MS = 120_000;
-
-export function getMcpToolTimeoutMs(): number {
-	const envValue = config.MCP_TOOL_TIMEOUT_MS;
-	if (envValue) {
-		const parsed = parseInt(envValue, 10);
-		if (!isNaN(parsed) && parsed > 0) {
-			return parsed;
-		}
-	}
-	return DEFAULT_TIMEOUT_MS;
-}
-
-export type McpToolTextResponse = {
-	text: string;
-	/** If the server returned structuredContent, include it raw */
-	structured?: unknown;
-	/** Raw content blocks returned by the server, if any */
-	content?: unknown[];
-};
-
-export type McpToolProgress = {
-	progress: number;
-	total?: number;
-	message?: string;
-};
-
-export async function callMcpTool(
-	server: McpServerConfig,
-	tool: string,
-	args: unknown = {},
-	{
-		timeoutMs = DEFAULT_TIMEOUT_MS,
-		signal,
-		client,
-		onProgress,
-	}: {
-		timeoutMs?: number;
-		signal?: AbortSignal;
-		client?: Client;
-		onProgress?: (progress: McpToolProgress) => void;
-	} = {}
-): Promise<McpToolTextResponse> {
-	const normalizedArgs =
-		typeof args === "object" && args !== null && !Array.isArray(args)
-			? (args as Record<string, unknown>)
-			: undefined;
-
-	// Get a (possibly pooled) client. The client itself was connected with a signal
-	// that already composes outer cancellation. We still enforce a per-call timeout here.
-	let activeClient = client ?? (await getClient(server, signal));
-
-	const callToolOptions = {
-		signal,
-		timeout: timeoutMs,
-		// Enable progress tokens so long-running tools keep extending the timeout.
-		onprogress: (progress: McpToolProgress) => {
-			onProgress?.({
-				progress: progress.progress,
-				total: progress.total,
-				message: progress.message,
-			});
-		},
-		resetTimeoutOnProgress: true,
-	};
-
-	let response;
-	try {
-		response = await activeClient.callTool(
-			{ name: tool, arguments: normalizedArgs },
-			undefined,
-			callToolOptions
-		);
-	} catch (err) {
-		if (!isConnectionClosedError(err)) {
-			throw err;
-		}
-
-		// Evict stale client and close it
-		const stale = evictFromPool(server);
-		stale?.close?.().catch(() => {});
-
-		// Retry with fresh client
-		activeClient = await getClient(server, signal);
-		response = await activeClient.callTool(
-			{ name: tool, arguments: normalizedArgs },
-			undefined,
-			callToolOptions
-		);
-	}
-
-	const parts = Array.isArray(response?.content) ? (response.content as Array<unknown>) : [];
-	const textParts = parts
-		.filter((part): part is { type: "text"; text: string } => {
-			if (typeof part !== "object" || part === null) return false;
-			const obj = part as Record<string, unknown>;
-			return obj["type"] === "text" && typeof obj["text"] === "string";
-		})
-		.map((p) => p.text);
-
-	const text = textParts.join("\n");
-	const structured = (response as unknown as { structuredContent?: unknown })?.structuredContent;
-	const contentBlocks = Array.isArray(response?.content)
-		? (response.content as unknown[])
-		: undefined;
-	return { text, structured, content: contentBlocks };
-}
+import { Client } from "@modelcontextprotocol/sdk/client";
+import { getClient, evictFromPool } from "./clientPool";
+import { config } from "$lib/server/config";
+
+function isConnectionClosedError(err: unknown): boolean {
+	const message = err instanceof Error ? err.message : String(err);
+	return message.includes("-32000") || message.toLowerCase().includes("connection closed");
+}
+
+export interface McpServerConfig {
+	name: string;
+	url: string;
+	headers?: Record<string, string>;
+}
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+
+export function getMcpToolTimeoutMs(): number {
+	const envValue = config.MCP_TOOL_TIMEOUT_MS;
+	if (envValue) {
+		const parsed = parseInt(envValue, 10);
+		if (!isNaN(parsed) && parsed > 0) {
+			return parsed;
+		}
+	}
+	return DEFAULT_TIMEOUT_MS;
+}
+
+export type McpToolTextResponse = {
+	text: string;
+	/** If the server returned structuredContent, include it raw */
+	structured?: unknown;
+	/** Raw content blocks returned by the server, if any */
+	content?: unknown[];
+};
+
+export type McpToolProgress = {
+	progress: number;
+	total?: number;
+	message?: string;
+};
+
+export async function callMcpTool(
+	server: McpServerConfig,
+	tool: string,
+	args: unknown = {},
+	{
+		timeoutMs = DEFAULT_TIMEOUT_MS,
+		signal,
+		client,
+		onProgress,
+	}: {
+		timeoutMs?: number;
+		signal?: AbortSignal;
+		client?: Client;
+		onProgress?: (progress: McpToolProgress) => void;
+	} = {}
+): Promise<McpToolTextResponse> {
+	const normalizedArgs =
+		typeof args === "object" && args !== null && !Array.isArray(args)
+			? (args as Record<string, unknown>)
+			: undefined;
+
+	// Get a (possibly pooled) client. The client itself was connected with a signal
+	// that already composes outer cancellation. We still enforce a per-call timeout here.
+	let activeClient = client ?? (await getClient(server, signal));
+
+	const callToolOptions = {
+		signal,
+		timeout: timeoutMs,
+		// Enable progress tokens so long-running tools keep extending the timeout.
+		onprogress: (progress: McpToolProgress) => {
+			onProgress?.({
+				progress: progress.progress,
+				total: progress.total,
+				message: progress.message,
+			});
+		},
+		resetTimeoutOnProgress: true,
+	};
+
+	let response;
+	try {
+		response = await activeClient.callTool(
+			{ name: tool, arguments: normalizedArgs },
+			undefined,
+			callToolOptions
+		);
+	} catch (err) {
+		if (!isConnectionClosedError(err)) {
+			throw err;
+		}
+
+		// Evict stale client and close it
+		const stale = evictFromPool(server);
+		stale?.close?.().catch(() => {});
+
+		// Retry with fresh client
+		activeClient = await getClient(server, signal);
+		response = await activeClient.callTool(
+			{ name: tool, arguments: normalizedArgs },
+			undefined,
+			callToolOptions
+		);
+	}
+
+	const parts = Array.isArray(response?.content) ? (response.content as Array<unknown>) : [];
+	const textParts = parts
+		.filter((part): part is { type: "text"; text: string } => {
+			if (typeof part !== "object" || part === null) return false;
+			const obj = part as Record<string, unknown>;
+			return obj["type"] === "text" && typeof obj["text"] === "string";
+		})
+		.map((p) => p.text);
+
+	const text = textParts.join("\n");
+	const structured = (response as unknown as { structuredContent?: unknown })?.structuredContent;
+	const contentBlocks = Array.isArray(response?.content)
+		? (response.content as unknown[])
+		: undefined;
+	return { text, structured, content: contentBlocks };
+}

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

@@ -1,76 +1,76 @@
-import { config } from "$lib/server/config";
-import { logger } from "$lib/server/logger";
-import type { McpServerConfig } from "./httpClient";
-import { resetMcpToolsCache } from "./tools";
-
-let cachedRaw: string | null = null;
-let cachedServers: McpServerConfig[] = [];
-
-function parseServers(raw: string): McpServerConfig[] {
-	if (!raw) return [];
-
-	try {
-		const parsed = JSON.parse(raw);
-		if (!Array.isArray(parsed)) return [];
-
-		return parsed
-			.map((entry) => {
-				if (!entry || typeof entry !== "object") return undefined;
-				const name = (entry as Record<string, unknown>).name;
-				const url = (entry as Record<string, unknown>).url;
-				if (typeof name !== "string" || !name.trim()) return undefined;
-				if (typeof url !== "string" || !url.trim()) return undefined;
-
-				const headersRaw = (entry as Record<string, unknown>).headers;
-				let headers: Record<string, string> | undefined;
-				if (headersRaw && typeof headersRaw === "object" && !Array.isArray(headersRaw)) {
-					const headerEntries = Object.entries(headersRaw as Record<string, unknown>).filter(
-						(entry): entry is [string, string] => typeof entry[1] === "string"
-					);
-					headers = Object.fromEntries(headerEntries);
-				}
-
-				return headers ? { name, url, headers } : { name, url };
-			})
-			.filter((server): server is McpServerConfig => Boolean(server));
-	} catch (error) {
-		logger.warn({ err: error }, "[mcp] failed to parse MCP_SERVERS env");
-		return [];
-	}
-}
-
-function setServers(raw: string) {
-	cachedServers = parseServers(raw);
-	cachedRaw = raw;
-	resetMcpToolsCache();
-	logger.debug({ count: cachedServers.length }, "[mcp] loaded server configuration");
-	console.log(
-		`[MCP] Loaded ${cachedServers.length} server(s):`,
-		cachedServers.map((s) => s.name).join(", ") || "none"
-	);
-}
-
-export function loadMcpServersOnStartup(): McpServerConfig[] {
-	const raw = config.MCP_SERVERS || "[]";
-	setServers(raw);
-	return cachedServers;
-}
-
-export function refreshMcpServersIfChanged(): void {
-	const currentRaw = config.MCP_SERVERS || "[]";
-	if (cachedRaw === null) {
-		setServers(currentRaw);
-		return;
-	}
-
-	if (currentRaw !== cachedRaw) {
-		setServers(currentRaw);
-	}
-}
-
-export function getMcpServers(): McpServerConfig[] {
-	if (cachedRaw === null) {
-		loadMcpServersOnStartup();
-	}
-	return cachedServers;
-}
+import { config } from "$lib/server/config";
+import { logger } from "$lib/server/logger";
+import type { McpServerConfig } from "./httpClient";
+import { resetMcpToolsCache } from "./tools";
+
+let cachedRaw: string | null = null;
+let cachedServers: McpServerConfig[] = [];
+
+function parseServers(raw: string): McpServerConfig[] {
+	if (!raw) return [];
+
+	try {
+		const parsed = JSON.parse(raw);
+		if (!Array.isArray(parsed)) return [];
+
+		return parsed
+			.map((entry) => {
+				if (!entry || typeof entry !== "object") return undefined;
+				const name = (entry as Record<string, unknown>).name;
+				const url = (entry as Record<string, unknown>).url;
+				if (typeof name !== "string" || !name.trim()) return undefined;
+				if (typeof url !== "string" || !url.trim()) return undefined;
+
+				const headersRaw = (entry as Record<string, unknown>).headers;
+				let headers: Record<string, string> | undefined;
+				if (headersRaw && typeof headersRaw === "object" && !Array.isArray(headersRaw)) {
+					const headerEntries = Object.entries(headersRaw as Record<string, unknown>).filter(
+						(entry): entry is [string, string] => typeof entry[1] === "string"
+					);
+					headers = Object.fromEntries(headerEntries);
+				}
+
+				return headers ? { name, url, headers } : { name, url };
+			})
+			.filter((server): server is McpServerConfig => Boolean(server));
+	} catch (error) {
+		logger.warn({ err: error }, "[mcp] failed to parse MCP_SERVERS env");
+		return [];
+	}
+}
+
+function setServers(raw: string) {
+	cachedServers = parseServers(raw);
+	cachedRaw = raw;
+	resetMcpToolsCache();
+	logger.debug({ count: cachedServers.length }, "[mcp] loaded server configuration");
+	console.log(
+		`[MCP] Loaded ${cachedServers.length} server(s):`,
+		cachedServers.map((s) => s.name).join(", ") || "none"
+	);
+}
+
+export function loadMcpServersOnStartup(): McpServerConfig[] {
+	const raw = config.MCP_SERVERS || "[]";
+	setServers(raw);
+	return cachedServers;
+}
+
+export function refreshMcpServersIfChanged(): void {
+	const currentRaw = config.MCP_SERVERS || "[]";
+	if (cachedRaw === null) {
+		setServers(currentRaw);
+		return;
+	}
+
+	if (currentRaw !== cachedRaw) {
+		setServers(currentRaw);
+	}
+}
+
+export function getMcpServers(): McpServerConfig[] {
+	if (cachedRaw === null) {
+		loadMcpServersOnStartup();
+	}
+	return cachedServers;
+}