@oisincoveney/pipeline 2.8.0 → 2.8.2

package/dist/gates.js

@@ -1,231 +1,12 @@
-import { parseJson } from "./safe-json.js";
-import { existsSync, readFileSync, renameSync } from "node:fs";
+import "./safe-json.js";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { execa } from "execa";
-import { resolveCommand } from "package-manager-detector/commands";
-import { detect } from "package-manager-detector/detect";
+import "execa";
+import "package-manager-detector/commands";
+import "package-manager-detector/detect";
 //#region src/gates.ts
-const FAILING_TEST_RE = /^[✗×✕●]\s+(.+)$/;
-function parseFailingTests(output) {
-	return output.split("\n").flatMap((line) => {
-		const m = FAILING_TEST_RE.exec(line);
-		return m ? [m[1].trim()] : [];
-	});
-}
-function displayCommand(command) {
-	return [command.command, ...command.args].join(" ");
-}
-function readPackageScripts(worktreePath) {
-	try {
-		return parseJson(readFileSync(join(worktreePath, "package.json"), "utf-8"), "package.json").scripts ?? {};
-	} catch {
-		return {};
-	}
-}
-function envCommand(envName) {
-	const raw = process.env[envName]?.trim();
-	if (!raw) return null;
-	return {
-		command: raw,
-		args: [],
-		shell: true
-	};
-}
-async function resolvePackageScript(worktreePath, scriptName) {
-	if (!readPackageScripts(worktreePath)[scriptName]) return null;
-	const resolved = resolveCommand(await detectPackageManagerAgent(worktreePath), "run", [scriptName]);
-	if (!resolved) return null;
-	return {
-		command: resolved.command,
-		args: resolved.args
-	};
-}
-async function detectPackageManagerAgent(worktreePath) {
-	return (await detect({
-		cwd: worktreePath,
-		stopDir: worktreePath
-	}))?.agent ?? "npm";
-}
-async function resolvePackageBinaryCommand(worktreePath, binary, args) {
-	if (!existsSync(join(worktreePath, "package.json"))) return null;
-	switch (await detectPackageManagerAgent(worktreePath)) {
-		case "bun": return {
-			command: "bun",
-			args: [
-				"x",
-				binary,
-				...args
-			]
-		};
-		case "pnpm": return {
-			command: "pnpm",
-			args: [
-				"exec",
-				binary,
-				...args
-			]
-		};
-		case "yarn": return {
-			command: "yarn",
-			args: [
-				"exec",
-				binary,
-				...args
-			]
-		};
-		default: return {
-			command: "npx",
-			args: [
-				"--yes",
-				binary,
-				...args
-			]
-		};
-	}
-}
-async function runTests(worktreePath, signal) {
-	const projectCommand = envCommand("PIPELINE_TEST_COMMAND") ?? await resolvePackageScript(worktreePath, "test");
-	if (!projectCommand) return {
-		exitCode: 1,
-		failingTests: [],
-		output: "No test command found. Set PIPELINE_TEST_COMMAND or define a package test script."
-	};
-	const result = await runProjectCommand(projectCommand, worktreePath, signal);
-	return {
-		...result,
-		failingTests: result.exitCode === 0 ? [] : parseFailingTests(result.output)
-	};
-}
-async function runTypecheck(worktreePath, signal) {
-	const projectCommand = envCommand("PIPELINE_TYPECHECK_COMMAND") ?? await resolvePackageScript(worktreePath, "typecheck");
-	if (!projectCommand) return {
-		exitCode: 0,
-		output: "skipped"
-	};
-	return await runProjectCommand(projectCommand, worktreePath, signal);
-}
-async function runLint(worktreePath, signal) {
-	const projectCommand = envCommand("PIPELINE_LINT_COMMAND") ?? await resolvePackageScript(worktreePath, "lint");
-	if (!projectCommand) return {
-		exitCode: 0,
-		output: "skipped"
-	};
-	return await runProjectCommand(projectCommand, worktreePath, signal, { hidePipelineRuns: true });
-}
-async function runFallow(worktreePath, signal) {
-	return runProjectCommand(envCommand("PIPELINE_FALLOW_COMMAND") ?? await resolvePackageScript(worktreePath, "fallow") ?? await resolvePackageBinaryCommand(worktreePath, "fallow", ["audit"]) ?? {
-		args: ["audit"],
-		command: "fallow"
-	}, worktreePath, signal, { hidePipelineRuns: true });
-}
-async function runProjectCommand(projectCommand, worktreePath, signal, options) {
-	const hiddenRuns = options?.hidePipelineRuns ? hidePipelineRunsDirectory(worktreePath) : null;
-	try {
-		const result = await execa(projectCommand.command, projectCommand.args, {
-			cancelSignal: signal,
-			cwd: worktreePath,
-			shell: projectCommand.shell
-		});
-		const output = [result.stdout, result.stderr].filter(Boolean).join("\n");
-		return {
-			command: displayCommand(projectCommand),
-			exitCode: result.exitCode ?? 0,
-			output
-		};
-	} catch (err) {
-		const e = commandError(err);
-		return {
-			command: displayCommand(projectCommand),
-			exitCode: e.exitCode ?? 1,
-			output: commandErrorOutput(e)
-		};
-	} finally {
-		hiddenRuns?.restore();
-	}
-}
-function hidePipelineRunsDirectory(worktreePath) {
-	const pipelineDir = join(worktreePath, ".pipeline");
-	const runsDir = join(pipelineDir, "runs");
-	if (!existsSync(runsDir)) return null;
-	const hiddenRunsDir = join(pipelineDir, `.runs-hidden-${process.pid}-${Date.now()}`);
-	renameSync(runsDir, hiddenRunsDir);
-	return { restore: () => {
-		if (!existsSync(hiddenRunsDir)) return;
-		renameSync(hiddenRunsDir, runsDir);
-	} };
-}
-function commandError(err) {
-	return err;
-}
-function commandErrorOutput(err) {
-	return [err.stdout, err.stderr].filter(Boolean).join("\n") || [err.shortMessage, err.message].filter(Boolean).join("\n");
-}
-async function runSemgrep(worktreePath, signal, changedFiles) {
-	const overrideCommand = envCommand("PIPELINE_SEMGREP_COMMAND");
-	const targets = changedFiles ? [...new Set(changedFiles)].filter((file) => existsSync(join(worktreePath, file))) : void 0;
-	if (!overrideCommand && targets && targets.length === 0) return {
-		command: "uvx semgrep scan --config=p/ci --error",
-		exitCode: 0,
-		output: "skipped: no changed files to scan"
-	};
-	return await runProjectCommand(overrideCommand ?? {
-		args: [
-			"semgrep",
-			"scan",
-			"--config=p/ci",
-			"--error",
-			...targets ? ["--", ...targets] : ["."]
-		],
-		command: "uvx"
-	}, worktreePath, signal);
-}
 function artifactExists(worktreePath, filename) {
 	return existsSync(join(worktreePath, filename));
 }
-const JSCPD_DEFAULT_IGNORES = [
-	"**/node_modules/**",
-	"**/.git/**",
-	"**/dist/**",
-	"**/coverage/**",
-	"**/.next/**",
-	"**/.turbo/**",
-	"**/.cache/**",
-	"**/.serena/**",
-	"**/.opencode/**",
-	"**/.pipeline/host-resources/**",
-	"**/.pipeline/skills/**",
-	"**/.agents/skills/**"
-];
-function parseJscpdOutput(output) {
-	try {
-		return { violations: (parseJson(output, "jscpd output")?.duplicates ?? []).map((dup) => ({
-			file: dup?.firstFile?.name ?? "unknown",
-			line: dup?.firstFile?.start,
-			message: `Duplicate code block detected between ${dup?.firstFile?.name} and ${dup?.secondFile?.name}`
-		})) };
-	} catch {
-		return { violations: [] };
-	}
-}
-async function runJscpd(worktreePath, signal) {
-	try {
-		return parseJscpdOutput((await execa("bunx", [
-			"jscpd",
-			"--min-tokens",
-			"50",
-			"--reporters",
-			"json",
-			"--gitignore",
-			"--ignore",
-			JSCPD_DEFAULT_IGNORES.join(","),
-			"."
-		], {
-			cancelSignal: signal,
-			cwd: worktreePath
-		})).stdout ?? "");
-	} catch (err) {
-		return parseJscpdOutput(err.stdout ?? "");
-	}
-}
 //#endregion
-export { artifactExists, runFallow, runJscpd, runLint, runSemgrep, runTests, runTypecheck };
+export { artifactExists };

package/dist/mcp/gateway-error.js

@@ -0,0 +1,15 @@
+import { Data } from "effect";
+//#region src/mcp/gateway-error.ts
+/**
+* Tagged error for the MCP (ToolHive) gateway subsystem. Lives in its own module
+* so both the gateway facade (src/mcp/gateway.ts) and the Effect service
+* (src/runtime/services/mcp-gateway-service.ts) can import it without forming a
+* circular dependency between them.
+*/
+var PipelineMcpGatewayError = class extends Data.TaggedError("PipelineMcpGatewayError") {
+	constructor(message) {
+		super({ message });
+	}
+};
+//#endregion
+export { PipelineMcpGatewayError };

package/dist/mcp/gateway.js

@@ -1,23 +1,22 @@
+import { PipelineMcpGatewayError } from "./gateway-error.js";
+import { McpGatewayService, McpGatewayServiceLive } from "../runtime/services/mcp-gateway-service.js";
 import { resolveRepoLocalBackendSpecs } from "./repo-local-backends.js";
 import { renderToolHiveVmcpInventory } from "./toolhive-vmcp.js";
-import { Data } from "effect";
+import { Effect } from "effect";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
-import { execa } from "execa";
 //#region src/mcp/gateway.ts
 const PIPELINE_GATEWAY_SERVER_ID = "pipeline-gateway";
 const DEFAULT_LOCAL_GATEWAY_URL = "http://127.0.0.1:4483/mcp";
 const LEGACY_OPENCODE_MCP_RE = /"mcp"\s*:\s*{(?!\s*"pipeline-gateway")/s;
 const LEGACY_PIPELINE_MCP_RE = /path:\s*\.mcp\.json|uvx\s+mcpm|mcpm\s+run/;
-var PipelineMcpGatewayError = class extends Data.TaggedError("PipelineMcpGatewayError") {
-	constructor(message) {
-		super({ message });
-	}
-};
 function profileNeedsMcpGateway(actor) {
 	return (actor?.mcp_servers ?? []).length > 0;
 }
+function runMcpGatewayEffect(program) {
+	return Effect.runPromise(Effect.provide(program, McpGatewayServiceLive));
+}
 function gatewayServerForProfile(config, actor, env = process.env) {
 	if (!(config && profileNeedsMcpGateway(actor))) return {};
 	return { [PIPELINE_GATEWAY_SERVER_ID]: gatewayServer(config, env) };
@@ -88,128 +87,79 @@ function configureGatewayHosts(config, options) {
 		};
 	});
 }
-async function runGatewayDoctor(config, cwd) {
-	const gateway = configuredGateway(config);
-	const checks = [
-		{
-			detail: `${gateway.provider}/${gateway.mode}`,
-			name: "gateway-config",
-			passed: true
-		},
-		checkGatewayUrl(gateway),
-		checkGatewayToken(gateway),
-		...gateway.mode === "local" ? [await checkThv(cwd)] : [],
-		await checkGatewayHealth(gateway),
-		await checkGatewayRequiredTools(gateway),
-		checkLegacyDirectMcp(cwd)
-	];
-	return {
-		checks,
-		passed: checks.every((check) => check.passed)
-	};
+function runGatewayDoctor(config, cwd) {
+	return runMcpGatewayEffect(Effect.gen(function* () {
+		const gateway = configuredGateway(config);
+		const checks = [
+			{
+				detail: `${gateway.provider}/${gateway.mode}`,
+				name: "gateway-config",
+				passed: true
+			},
+			checkGatewayUrl(gateway),
+			checkGatewayToken(gateway),
+			...gateway.mode === "local" ? [yield* checkThv(cwd)] : [],
+			yield* checkGatewayHealth(gateway),
+			yield* checkGatewayRequiredTools(gateway),
+			checkLegacyDirectMcp(cwd)
+		];
+		return {
+			checks,
+			passed: checks.every((check) => check.passed)
+		};
+	}));
 }
-async function startLocalGateway(config, cwd) {
-	if (configuredGateway(config).mode !== "local") throw new PipelineMcpGatewayError("mcp gateway local-start is only valid when mcp_gateway.mode is local.");
-	const result = await reconcileGateway(config, cwd);
-	if (result.readinessFailures.length > 0) throw new PipelineMcpGatewayError(`Cannot start local MCP gateway; readiness failures: ${result.readinessFailures.join("; ")}`);
-	await execa("thv", [
-		"vmcp",
-		"serve",
-		"--config",
-		result.configPath,
-		"--host",
-		"127.0.0.1",
-		"--port",
-		"4483"
-	], {
-		cwd,
-		env: await toolhiveEnv(cwd),
-		stderr: "inherit",
-		stdout: "inherit"
-	});
+function startLocalGateway(config, cwd) {
+	return runMcpGatewayEffect(Effect.gen(function* () {
+		if (configuredGateway(config).mode !== "local") return yield* Effect.fail(new PipelineMcpGatewayError("mcp gateway local-start is only valid when mcp_gateway.mode is local."));
+		const result = yield* reconcileGatewayEffect(config, cwd, process.env);
+		if (result.readinessFailures.length > 0) return yield* Effect.fail(new PipelineMcpGatewayError(`Cannot start local MCP gateway; readiness failures: ${result.readinessFailures.join("; ")}`));
+		yield* (yield* McpGatewayService).serveToolHiveVmcp(result.configPath, cwd);
+	}));
 }
-async function reconcileGateway(config, cwd, env = process.env) {
-	const gateway = configuredGateway(config);
-	if (gateway.provider !== "toolhive") throw new PipelineMcpGatewayError(`Unsupported MCP gateway provider '${gateway.provider}'.`);
-	const workspacePath = env.PIPELINE_TARGET_PATH || cwd;
-	const repoLocalBackends = resolveRepoLocalBackendSpecs(config, {
-		cwd: workspacePath,
-		env
-	});
-	const inventory = renderToolHiveVmcpInventory(config, {
-		repoLocalBackends,
-		toolHiveWorkloads: await listToolHiveGroupWorkloads(gateway.default_profile ?? "default", workspacePath)
-	});
-	const configPath = join(workspacePath, ".pipeline", "mcp-gateway", "vmcp.yaml");
-	mkdirSync(dirname(configPath), { recursive: true });
-	writeFileSync(configPath, inventory.yaml);
-	await execa("thv", [
-		"vmcp",
-		"validate",
-		"--config",
-		configPath
-	], {
-		cwd: workspacePath,
-		env: await toolhiveEnv(workspacePath),
-		stdin: "ignore"
-	});
-	return {
-		backendCount: inventory.backends.length,
-		configPath,
-		readinessFailures: [...repoLocalBackends.filter((backend) => backend.enabled && !backend.readiness.ok).map((backend) => `${backend.id}: ${backend.readiness.reason}`), ...inventory.backends.filter((backend) => backend.enabled && backend.required && !backend.url).map((backend) => `${backend.name}: missing ToolHive workload`)],
-		workspacePath
-	};
+function reconcileGateway(config, cwd, env = process.env) {
+	return runMcpGatewayEffect(reconcileGatewayEffect(config, cwd, env));
 }
-async function listToolHiveGroupWorkloads(group, cwd) {
-	const result = await execa("thv", [
-		"list",
-		"--group",
-		group,
-		"--format",
-		"json"
-	], {
-		cwd,
-		env: await toolhiveEnv(cwd),
-		stdin: "ignore"
-	});
-	let parsed;
-	const stdout = result.stdout.trim();
-	if (!stdout) return [];
-	try {
-		parsed = JSON.parse(stdout);
-	} catch {
-		throw new PipelineMcpGatewayError("ToolHive list returned malformed JSON while reconciling MCP gateway workloads.");
-	}
-	if (!Array.isArray(parsed)) throw new PipelineMcpGatewayError("ToolHive list returned a non-array payload while reconciling MCP gateway workloads.");
-	return parsed.flatMap((item) => {
-		if (!item || typeof item.name !== "string") return [];
-		return [{
-			name: item.name,
-			status: typeof item.status === "string" ? item.status : void 0,
-			transport: toolHiveWorkloadTransport(item),
-			url: typeof item.url === "string" ? item.url : void 0
-		}];
+function reconcileGatewayEffect(config, cwd, env) {
+	const gateway = configuredGateway(config);
+	if (gateway.provider !== "toolhive") return Effect.fail(new PipelineMcpGatewayError(`Unsupported MCP gateway provider '${gateway.provider}'.`));
+	return Effect.gen(function* () {
+		const service = yield* McpGatewayService;
+		const workspacePath = env.PIPELINE_TARGET_PATH || cwd;
+		const repoLocalBackends = resolveRepoLocalBackendSpecs(config, {
+			cwd: workspacePath,
+			env
+		});
+		const inventory = renderToolHiveVmcpInventory(config, {
+			repoLocalBackends,
+			toolHiveWorkloads: yield* service.listToolHiveGroupWorkloads(gateway.default_profile ?? "default", workspacePath)
+		});
+		const configPath = join(workspacePath, ".pipeline", "mcp-gateway", "vmcp.yaml");
+		mkdirSync(dirname(configPath), { recursive: true });
+		writeFileSync(configPath, inventory.yaml);
+		yield* service.validateToolHiveVmcp(configPath, workspacePath);
+		return {
+			backendCount: inventory.backends.length,
+			configPath,
+			readinessFailures: [...repoLocalBackends.filter((backend) => backend.enabled && !backend.readiness.ok).map((backend) => `${backend.id}: ${backend.readiness.reason}`), ...inventory.backends.filter((backend) => backend.enabled && backend.required && !backend.url).map((backend) => `${backend.name}: missing ToolHive workload`)],
+			workspacePath
+		};
 	});
 }
-function toolHiveWorkloadTransport(item) {
-	if (typeof item.transport_type === "string") return item.transport_type;
-	if (typeof item.transport === "string") return item.transport;
-}
-async function localGatewayStatus(cwd) {
-	return (await execa("thv", ["list"], {
-		cwd,
-		env: await toolhiveEnv(cwd)
-	})).stdout.trim();
+function localGatewayStatus(cwd) {
+	return runMcpGatewayEffect(Effect.gen(function* () {
+		return yield* (yield* McpGatewayService).localGatewayStatus(cwd);
+	}));
 }
-async function checkGatewayRequiredTools(gateway) {
+function checkGatewayRequiredTools(gateway) {
 	const requiredPrefixes = requiredGatewayToolPrefixes(gateway);
-	if (requiredPrefixes.length === 0) return {
+	if (requiredPrefixes.length === 0) return Effect.succeed({
 		detail: "no required tools declared",
 		name: "gateway-required-tools",
 		passed: true
-	};
-	try {
-		const tools = await listGatewayTools(gateway);
+	});
+	return Effect.gen(function* () {
+		const tools = yield* listGatewayTools(gateway);
 		const missing = requiredPrefixes.filter((prefix) => !tools.some((tool) => tool === prefix || tool.startsWith(`${prefix}_`)));
 		return missing.length === 0 ? {
 			detail: `found: ${requiredPrefixes.join(", ")}`,
@@ -220,54 +170,45 @@ async function checkGatewayRequiredTools(gateway) {
 			name: "gateway-required-tools",
 			passed: false
 		};
-	} catch (err) {
-		return {
-			detail: err instanceof Error ? err.message : String(err),
-			name: "gateway-required-tools",
-			passed: false
-		};
-	}
+	}).pipe(Effect.catchAll((error) => Effect.succeed({
+		detail: error instanceof Error ? error.message : String(error),
+		name: "gateway-required-tools",
+		passed: false
+	})));
 }
 function requiredGatewayToolPrefixes(gateway) {
 	return [...new Set(Object.values(gateway.backends).filter((backend) => backend.required).flatMap((backend) => backend.tool_prefixes))].sort();
 }
-async function listGatewayTools(gateway) {
+function listGatewayTools(gateway) {
 	const url = gatewayUrl(gateway);
-	await callGatewayRpc(gateway, url, {
-		id: 1,
-		jsonrpc: "2.0",
-		method: "initialize",
-		params: {
-			capabilities: {},
-			clientInfo: {
-				name: "@oisincoveney/pipeline",
-				version: "1"
-			},
-			protocolVersion: "2025-06-18"
-		}
+	return Effect.gen(function* () {
+		yield* callGatewayRpc(gateway, url, {
+			id: 1,
+			jsonrpc: "2.0",
+			method: "initialize",
+			params: {
+				capabilities: {},
+				clientInfo: {
+					name: "@oisincoveney/pipeline",
+					version: "1"
+				},
+				protocolVersion: "2025-06-18"
+			}
+		});
+		const tools = (yield* callGatewayRpc(gateway, url, {
+			id: 2,
+			jsonrpc: "2.0",
+			method: "tools/list",
+			params: {}
+		})).result?.tools;
+		if (!Array.isArray(tools)) return yield* Effect.fail(new PipelineMcpGatewayError("Malformed tools/list response."));
+		return tools.flatMap((tool) => tool && typeof tool.name === "string" ? [tool.name] : []);
 	});
-	const tools = (await callGatewayRpc(gateway, url, {
-		id: 2,
-		jsonrpc: "2.0",
-		method: "tools/list",
-		params: {}
-	})).result?.tools;
-	if (!Array.isArray(tools)) throw new PipelineMcpGatewayError("Malformed tools/list response.");
-	return tools.flatMap((tool) => tool && typeof tool.name === "string" ? [tool.name] : []);
-}
-async function callGatewayRpc(gateway, url, body) {
-	const authorization = process.env[gateway.authorization_env];
-	const response = await fetch(url, {
-		body: JSON.stringify(body),
-		headers: {
-			Accept: "application/json",
-			"Content-Type": "application/json",
-			...authorization ? { Authorization: authorization } : {}
-		},
-		method: "POST"
+}
+function callGatewayRpc(gateway, url, body) {
+	return Effect.gen(function* () {
+		return yield* (yield* McpGatewayService).callGatewayRpc(url, body, process.env[gateway.authorization_env]);
 	});
-	if (!response.ok) throw new PipelineMcpGatewayError(`Gateway MCP request failed: HTTP ${response.status}.`);
-	return await response.json();
 }
 function selectedGatewayHosts(host) {
 	return host === "all" ? ["opencode"] : [host];
@@ -314,86 +255,44 @@ function gatewayAuthorizationHeader(gateway) {
 function gatewayOpenCodeHeaders(gateway) {
 	return { Authorization: gatewayAuthorizationHeader(gateway) };
 }
-async function checkThv(cwd) {
-	try {
-		await execa("thv", ["version"], {
-			cwd,
-			env: await toolhiveEnv(cwd),
-			stdin: "ignore"
-		});
+function checkThv(cwd) {
+	return Effect.gen(function* () {
+		yield* (yield* McpGatewayService).runToolHiveVersion(cwd);
 		return {
 			detail: "available",
 			name: "toolhive",
 			passed: true
 		};
-	} catch (err) {
-		const error = err;
-		return {
-			detail: (error.shortMessage || error.stderr || "not available").trim(),
-			name: "toolhive",
-			passed: false
-		};
-	}
-}
-async function toolhiveEnv(cwd) {
-	if (process.env.DOCKER_HOST) return process.env;
-	const dockerHost = await activeDockerHost(cwd);
-	return dockerHost ? {
-		...process.env,
-		DOCKER_HOST: dockerHost
-	} : process.env;
-}
-async function activeDockerHost(cwd) {
-	try {
-		const result = await execa("docker", ["context", "inspect"], {
-			cwd,
-			stdin: "ignore"
-		});
-		const host = JSON.parse(result.stdout)[0]?.Endpoints?.docker?.Host;
-		return typeof host === "string" && host.length > 0 ? host : void 0;
-	} catch {
-		return;
-	}
+	}).pipe(Effect.catchAll((error) => Effect.succeed({
+		detail: error.message || "not available",
+		name: "toolhive",
+		passed: false
+	})));
 }
-async function checkGatewayHealth(gateway) {
+function checkGatewayHealth(gateway) {
 	let url;
 	try {
 		url = gatewayUrl(gateway);
 	} catch (err) {
-		return {
+		return Effect.succeed({
 			detail: err instanceof Error ? err.message : String(err),
 			name: "gateway-health",
 			passed: false
-		};
+		});
 	}
-	try {
-		const response = await firstHealthyGatewayResponse(url, gateway);
+	return Effect.gen(function* () {
+		const response = yield* (yield* McpGatewayService).firstHealthyGatewayResponse(gatewayHealthUrls(url), process.env[gateway.authorization_env]);
 		const passed = Boolean(response);
 		return {
 			detail: response ? `HTTP ${response.status} ${response.url}` : "gateway endpoint did not report healthy",
 			name: "gateway-health",
 			passed
 		};
-	} catch (err) {
-		return {
-			detail: err instanceof Error ? err.message : String(err),
-			name: "gateway-health",
-			passed: false
-		};
-	}
-}
-async function firstHealthyGatewayResponse(url, gateway) {
-	const authorization = process.env[gateway.authorization_env];
-	for (const healthUrl of gatewayHealthUrls(url)) {
-		const response = await fetch(healthUrl, {
-			headers: {
-				Accept: "application/json, text/event-stream",
-				...authorization ? { Authorization: authorization } : {}
-			},
-			method: "GET"
-		});
-		if (response.status >= 200 && response.status < 300 || response.status === 405) return response;
-	}
+	}).pipe(Effect.catchAll((error) => Effect.succeed({
+		detail: error instanceof Error ? error.message : String(error),
+		name: "gateway-health",
+		passed: false
+	})));
 }
 function gatewayHealthUrls(url) {
 	const urls = [];