@oisincoveney/pipeline 2.8.0 → 2.8.2

package/dist/runtime/services/mcp-gateway-service.js

@@ -0,0 +1,184 @@
+import { PipelineMcpGatewayError } from "../../mcp/gateway-error.js";
+import { Context, Effect, Layer } from "effect";
+import { execa } from "execa";
+//#region src/runtime/services/mcp-gateway-service.ts
+function gatewayError(message) {
+	return new PipelineMcpGatewayError(message);
+}
+function execaErrorMessage(error) {
+	const subprocessError = error;
+	const subprocessMessage = subprocessError.shortMessage || subprocessError.stderr;
+	if (subprocessMessage) return subprocessMessage.trim();
+	return error instanceof Error ? error.message : String(error);
+}
+function execaGatewayError(error) {
+	return error instanceof PipelineMcpGatewayError ? error : gatewayError(execaErrorMessage(error));
+}
+function toolHiveWorkloadTransport(item) {
+	if (typeof item.transport_type === "string") return item.transport_type;
+	if (typeof item.transport === "string") return item.transport;
+}
+function parseToolHiveWorkloads(stdout) {
+	const trimmed = stdout.trim();
+	if (!trimmed) return [];
+	let parsed;
+	try {
+		parsed = JSON.parse(trimmed);
+	} catch {
+		throw gatewayError("ToolHive list returned malformed JSON while reconciling MCP gateway workloads.");
+	}
+	if (!Array.isArray(parsed)) throw gatewayError("ToolHive list returned a non-array payload while reconciling MCP gateway workloads.");
+	return parsed.flatMap((item) => toToolHiveWorkload(item));
+}
+function asString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function toToolHiveWorkload(item) {
+	if (!item || typeof item.name !== "string") return [];
+	return [{
+		name: item.name,
+		status: asString(item.status),
+		transport: toolHiveWorkloadTransport(item),
+		url: asString(item.url)
+	}];
+}
+function isHealthyGatewayStatus(status) {
+	return status >= 200 && status < 300 || status === 405;
+}
+function activeDockerHost(cwd) {
+	return Effect.tryPromise({
+		catch: () => void 0,
+		try: async () => {
+			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;
+		}
+	}).pipe(Effect.catchAll(() => Effect.succeed(void 0)));
+}
+function toolhiveEnv(cwd) {
+	if (process.env.DOCKER_HOST) return Effect.succeed(process.env);
+	return activeDockerHost(cwd).pipe(Effect.map((dockerHost) => dockerHost ? {
+		...process.env,
+		DOCKER_HOST: dockerHost
+	} : process.env));
+}
+function fetchGateway(url, init) {
+	return Effect.tryPromise({
+		catch: execaGatewayError,
+		try: () => fetch(url, init)
+	});
+}
+var McpGatewayService = class extends Context.Tag("McpGatewayService")() {};
+const McpGatewayServiceLive = Layer.succeed(McpGatewayService, {
+	callGatewayRpc: (url, body, authorization) => fetchGateway(url, {
+		body: JSON.stringify(body),
+		headers: {
+			Accept: "application/json",
+			"Content-Type": "application/json",
+			...authorization ? { Authorization: authorization } : {}
+		},
+		method: "POST"
+	}).pipe(Effect.flatMap((response) => {
+		if (!response.ok) return Effect.fail(gatewayError(`Gateway MCP request failed: HTTP ${response.status}.`));
+		return Effect.tryPromise({
+			catch: execaGatewayError,
+			try: () => response.json()
+		});
+	})),
+	firstHealthyGatewayResponse: (urls, authorization) => Effect.gen(function* () {
+		for (const url of urls) {
+			const response = yield* fetchGateway(url, {
+				headers: {
+					Accept: "application/json, text/event-stream",
+					...authorization ? { Authorization: authorization } : {}
+				},
+				method: "GET"
+			});
+			if (isHealthyGatewayStatus(response.status)) return response;
+		}
+	}),
+	listToolHiveGroupWorkloads: (group, cwd) => Effect.gen(function* () {
+		const env = yield* toolhiveEnv(cwd);
+		const result = yield* Effect.tryPromise({
+			catch: execaGatewayError,
+			try: () => execa("thv", [
+				"list",
+				"--group",
+				group,
+				"--format",
+				"json"
+			], {
+				cwd,
+				env,
+				stdin: "ignore"
+			})
+		});
+		return yield* Effect.try({
+			catch: execaGatewayError,
+			try: () => parseToolHiveWorkloads(result.stdout)
+		});
+	}),
+	localGatewayStatus: (cwd) => Effect.gen(function* () {
+		const env = yield* toolhiveEnv(cwd);
+		return (yield* Effect.tryPromise({
+			catch: execaGatewayError,
+			try: () => execa("thv", ["list"], {
+				cwd,
+				env
+			})
+		})).stdout.trim();
+	}),
+	runToolHiveVersion: (cwd) => Effect.gen(function* () {
+		const env = yield* toolhiveEnv(cwd);
+		yield* Effect.tryPromise({
+			catch: execaGatewayError,
+			try: () => execa("thv", ["version"], {
+				cwd,
+				env,
+				stdin: "ignore"
+			})
+		});
+	}),
+	serveToolHiveVmcp: (configPath, cwd) => Effect.gen(function* () {
+		const env = yield* toolhiveEnv(cwd);
+		yield* Effect.tryPromise({
+			catch: execaGatewayError,
+			try: () => execa("thv", [
+				"vmcp",
+				"serve",
+				"--config",
+				configPath,
+				"--host",
+				"127.0.0.1",
+				"--port",
+				"4483"
+			], {
+				cwd,
+				env,
+				stderr: "inherit",
+				stdout: "inherit"
+			})
+		});
+	}),
+	validateToolHiveVmcp: (configPath, cwd) => Effect.gen(function* () {
+		const env = yield* toolhiveEnv(cwd);
+		yield* Effect.tryPromise({
+			catch: execaGatewayError,
+			try: () => execa("thv", [
+				"vmcp",
+				"validate",
+				"--config",
+				configPath
+			], {
+				cwd,
+				env,
+				stdin: "ignore"
+			})
+		});
+	})
+});
+//#endregion
+export { McpGatewayService, McpGatewayServiceLive };

package/dist/runtime/services/opencode-sdk-service.js

@@ -0,0 +1,27 @@
+import { Context, Effect, Layer } from "effect";
+import { createOpencode, createOpencodeClient } from "@opencode-ai/sdk";
+//#region src/runtime/services/opencode-sdk-service.ts
+var OpencodeSdkService = class extends Context.Tag("OpencodeSdkService")() {};
+const OpencodeSdkServiceLive = Layer.succeed(OpencodeSdkService, {
+	createClient: (opts) => Effect.try(() => createOpencodeClient(opts)),
+	createSession: (client, args) => Effect.tryPromise({
+		catch: (error) => error,
+		try: () => client.session.create(args)
+	}),
+	promptSession: (client, args) => Effect.tryPromise({
+		catch: (error) => error,
+		try: () => client.session.prompt(args)
+	}),
+	spawnServer: (args, spawn = createOpencode) => Effect.tryPromise({
+		catch: (error) => error,
+		try: () => spawn(args)
+	}),
+	subscribeEvents: (client) => Effect.tryPromise({
+		catch: (error) => error,
+		try: async () => {
+			return { stream: (await client.event.subscribe()).stream };
+		}
+	})
+});
+//#endregion
+export { OpencodeSdkService, OpencodeSdkServiceLive };

package/dist/runtime/services/runner-event-sink-http-service.js

@@ -0,0 +1,80 @@
+import { Context, Data, Effect, Layer } from "effect";
+import ky, { isHTTPError } from "ky";
+//#region src/runtime/services/runner-event-sink-http-service.ts
+var EventSinkHttpError = class extends Data.TaggedError("EventSinkHttpError") {
+	constructor(status, message) {
+		super({
+			status,
+			message
+		});
+	}
+};
+const RETRYABLE_STATUS_CODES = [
+	408,
+	429,
+	500,
+	501,
+	502,
+	503,
+	504,
+	505,
+	506,
+	507,
+	508,
+	509,
+	510,
+	511
+];
+function authHeaderName(request) {
+	return request.authHeader ?? "Authorization";
+}
+function httpErrorData(error) {
+	return formatHttpErrorData(isHTTPError(error) ? error.data : void 0);
+}
+function formatHttpErrorData(data) {
+	if (typeof data === "string") return data;
+	return data === void 0 ? "" : JSON.stringify(data);
+}
+function toError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+function toHttpError(error) {
+	const data = httpErrorData(error);
+	const status = isHTTPError(error) ? error.response.status : 0;
+	return new EventSinkHttpError(status, `Event sink responded with ${status}${data ? `: ${data}` : ""}`);
+}
+function mapPostError(error) {
+	return isHTTPError(error) ? toHttpError(error) : toError(error);
+}
+function kyFetchAdapter(fetchImpl) {
+	return async (input, init) => {
+		const request = new Request(input, init);
+		return fetchImpl(request.url, {
+			body: await request.clone().text(),
+			headers: request.headers,
+			method: request.method,
+			signal: request.signal
+		});
+	};
+}
+function postBatch(request) {
+	return Effect.tryPromise({
+		catch: mapPostError,
+		try: () => ky.post(request.url, {
+			fetch: kyFetchAdapter(request.fetch),
+			headers: { [authHeaderName(request)]: `Bearer ${request.authToken}` },
+			json: { events: request.events },
+			retry: {
+				delay: () => request.retryDelayMs,
+				limit: request.maxRetries,
+				methods: ["post"],
+				retryOnTimeout: true,
+				statusCodes: RETRYABLE_STATUS_CODES
+			}
+		}).then(() => void 0)
+	});
+}
+var RunnerEventSinkHttpService = class extends Context.Tag("RunnerEventSinkHttpService")() {};
+const RunnerEventSinkHttpServiceLive = Layer.succeed(RunnerEventSinkHttpService, { postBatch });
+//#endregion
+export { RunnerEventSinkHttpService, RunnerEventSinkHttpServiceLive };

package/dist/runtime/services/select-candidate-service.js

@@ -0,0 +1,13 @@
+import { promoteWorktreeChanges } from "../parallel-worktrees/parallel-worktrees.js";
+import { Context, Effect, Layer } from "effect";
+//#region src/runtime/services/select-candidate-service.ts
+var SelectCandidateService = class extends Context.Tag("SelectCandidateService")() {};
+const SelectCandidateServiceLive = Layer.succeed(SelectCandidateService, {
+	executeRunner: (executor, plan, options) => Effect.tryPromise({
+		catch: (error) => error,
+		try: () => Promise.resolve(executor(plan, options))
+	}),
+	promoteWinner: (repoRoot, runId, parentNodeId, childNodeId) => Effect.sync(() => promoteWorktreeChanges(repoRoot, runId, parentNodeId, childNodeId))
+});
+//#endregion
+export { SelectCandidateService, SelectCandidateServiceLive };

package/package.json

@@ -126,7 +126,7 @@
     "prepack": "bun run build:cli"
   },
   "type": "module",
-  "version": "2.8.0",
+  "version": "2.8.2",
   "description": "Config-driven multi-agent pipeline runner for repository work",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",