@oisincoveney/pipeline 2.8.0 → 2.8.2

package/dist/runtime/drain-merge/drain-merge.js

@@ -2,12 +2,16 @@ import { parseJsonObject } from "../json-validation/json-validation.js";
 import "../json-validation/index.js";
 import { generateRuntimeRunId } from "../context/context.js";
 import "../context/index.js";
-import simpleGit$1 from "simple-git";
+import { DrainMergeGitService, DrainMergeGitServiceLive } from "../services/drain-merge-git-service.js";
+import { Effect } from "effect";
 //#region src/runtime/drain-merge/drain-merge.ts
 const LINE_RE = /\r?\n/;
-async function executeDrainMergeBuiltin(context, node) {
-	const upstreamNodeId = node?.needs.at(0) ?? null;
-	const integrationBranch = `runs/integration/${context.runId ?? generateRuntimeRunId()}`;
+function executeDrainMergeBuiltin(context, node) {
+	return Effect.runPromise(Effect.provide(drainMergeProgram(context, node), DrainMergeGitServiceLive));
+}
+function drainMergeProgram(context, node) {
+	const upstreamNodeId = firstNeededNode(node);
+	const integrationBranch = `runs/integration/${runIdForDrainMerge(context)}`;
 	const report = {
 		baseSha: null,
 		conflicts: [],
@@ -16,47 +20,31 @@ async function executeDrainMergeBuiltin(context, node) {
 		skipped: []
 	};
 	const mergeable = drainMergeMergeableChildren(drainMergeChildren(context, upstreamNodeId), report);
-	if (mergeable.length === 0) return drainMergeResult(report);
-	report.baseSha = mergeable[0].output.baseSha;
-	const divergent = mergeable.find((child) => child.output.baseSha !== report.baseSha);
-	if (divergent) return drainMergeResult(report, {
+	if (mergeable.length === 0) return Effect.succeed(drainMergeResult(report));
+	const baseSha = mergeable[0].output.baseSha;
+	report.baseSha = baseSha;
+	const divergent = divergentDrainMergeChild(mergeable, baseSha);
+	if (divergent) return Effect.succeed(drainMergeResult(report, {
 		evidence: [`drain-merge child '${divergent.nodeId}' baseSha ${divergent.output.baseSha} diverges from ${report.baseSha}`],
 		failed: true
-	});
-	const git = simpleGit$1({ baseDir: context.worktreePath });
-	try {
-		await checkoutDrainMergeIntegrationBranch(git, integrationBranch, report.baseSha);
-	} catch (error) {
-		return drainMergeResult(report, {
-			evidence: [`drain-merge setup-error: ${error instanceof Error ? error.message : String(error)}`],
-			failed: true
-		});
-	}
-	for (const child of mergeable) try {
-		await git.raw([
-			"merge",
-			"--no-ff",
-			"--no-edit",
-			"-m",
-			"drain-merge: merge",
-			child.output.branch
-		]);
-		report.merged.push({
-			branch: child.output.branch,
-			id: child.nodeId,
-			worktreePath: child.output.worktreePath
+	}));
+	return Effect.gen(function* () {
+		const git = yield* (yield* DrainMergeGitService).create(context.worktreePath);
+		const setup = checkoutDrainMergeIntegrationBranch(git, integrationBranch, baseSha);
+		const setupResult = yield* Effect.either(setup);
+		if (setupResult._tag === "Left") return drainMergeSetupErrorResult(report, setupResult.left);
+		yield* Effect.forEach(mergeable, (child) => mergeDrainMergeChild(git, report, child), {
+			concurrency: 1,
+			discard: true
 		});
-	} catch {
-		const files = await drainMergeConflictFiles(git);
-		report.conflicts.push({
-			branch: child.output.branch,
-			files,
-			id: child.nodeId,
-			worktreePath: child.output.worktreePath
-		});
-		await abortDrainMerge(git);
-	}
-	return drainMergeResult(report);
+		return drainMergeResult(report);
+	});
+}
+function firstNeededNode(node) {
+	return node?.needs.at(0) ?? null;
+}
+function runIdForDrainMerge(context) {
+	return context.runId ?? generateRuntimeRunId();
 }
 function drainMergeChildren(context, upstreamNodeId) {
 	if (!upstreamNodeId) return [];
@@ -80,7 +68,7 @@ function drainMergeMergeableChildren(children, report) {
 			});
 			return [];
 		}
-		if (!(child.output.baseSha && child.output.branch && child.output.worktreePath)) {
+		if (!hasDrainMergeWorktree(child.output)) {
 			report.skipped.push({
 				id: child.nodeId,
 				reason: "no-worktree",
@@ -99,56 +87,110 @@ function drainMergeMergeableChildren(children, report) {
 		}];
 	});
 }
-async function checkoutDrainMergeIntegrationBranch(git, integrationBranch, baseSha) {
-	try {
-		await git.raw([
-			"rev-parse",
-			"--verify",
-			integrationBranch
-		]);
-		await git.raw(["checkout", integrationBranch]);
-	} catch {
-		await git.raw([
-			"checkout",
-			"-b",
-			integrationBranch,
-			baseSha
-		]);
-	}
-}
-async function drainMergeConflictFiles(git) {
-	try {
-		return (await git.raw([
-			"diff",
-			"--name-only",
-			"--diff-filter=U"
-		])).split(LINE_RE).filter(Boolean);
-	} catch {
-		return [];
-	}
-}
-async function abortDrainMerge(git) {
-	try {
-		await git.raw(["merge", "--abort"]);
-	} catch {}
+function hasDrainMergeWorktree(output) {
+	return Boolean(output.baseSha) && Boolean(output.branch) && Boolean(output.worktreePath);
+}
+function divergentDrainMergeChild(mergeable, baseSha) {
+	return mergeable.find((child) => child.output.baseSha !== baseSha);
+}
+function checkoutDrainMergeIntegrationBranch(git, integrationBranch, baseSha) {
+	return git.raw([
+		"rev-parse",
+		"--verify",
+		integrationBranch
+	]).pipe(Effect.flatMap(() => git.raw(["checkout", integrationBranch])), Effect.catchAll(() => git.raw([
+		"checkout",
+		"-b",
+		integrationBranch,
+		baseSha
+	])), Effect.asVoid);
+}
+function mergeDrainMergeChild(git, report, child) {
+	return drainMergeChild(git, child.output.branch).pipe(Effect.tap(() => Effect.sync(() => recordDrainMergeSuccess(report, child))), Effect.catchAll(() => recordDrainMergeConflict(git, report, child)));
+}
+function drainMergeChild(git, branch) {
+	return git.raw([
+		"merge",
+		"--no-ff",
+		"--no-edit",
+		"-m",
+		"drain-merge: merge",
+		branch
+	]);
+}
+function recordDrainMergeSuccess(report, child) {
+	report.merged.push({
+		branch: child.output.branch,
+		id: child.nodeId,
+		worktreePath: child.output.worktreePath
+	});
+}
+function recordDrainMergeConflict(git, report, child) {
+	return Effect.gen(function* () {
+		const files = yield* drainMergeConflictFiles(git);
+		report.conflicts.push({
+			branch: child.output.branch,
+			files,
+			id: child.nodeId,
+			worktreePath: child.output.worktreePath
+		});
+		yield* abortDrainMerge(git);
+	});
+}
+function drainMergeConflictFiles(git) {
+	return git.raw([
+		"diff",
+		"--name-only",
+		"--diff-filter=U"
+	]).pipe(Effect.map((output) => output.split(LINE_RE).filter(Boolean)), Effect.catchAll(() => Effect.succeed([])));
+}
+function abortDrainMerge(git) {
+	return git.raw(["merge", "--abort"]).pipe(Effect.catchAll(() => Effect.void), Effect.asVoid);
 }
 function parseDrainMergeChildOutput(value) {
 	const output = parseJsonObject(value);
 	if (Object.keys(output).length === 0) return null;
 	return {
-		baseSha: typeof output.baseSha === "string" ? output.baseSha : null,
-		branch: typeof output.branch === "string" ? output.branch : null,
-		status: output.status === "PASS" ? "PASS" : "FAIL",
-		worktreePath: typeof output.worktreePath === "string" ? output.worktreePath : null
+		baseSha: stringFieldOrNull(output.baseSha),
+		branch: stringFieldOrNull(output.branch),
+		status: drainMergeStatus(output.status),
+		worktreePath: stringFieldOrNull(output.worktreePath)
 	};
 }
+function stringFieldOrNull(value) {
+	return typeof value === "string" ? value : null;
+}
+function drainMergeStatus(value) {
+	return value === "PASS" ? "PASS" : "FAIL";
+}
 function drainMergeResult(report, options = {}) {
-	const hasFailure = report.conflicts.length > 0 || options.failed === true;
+	const hasFailure = hasDrainMergeFailure(report, options.failed);
 	return {
-		evidence: [...options.evidence ?? [], hasFailure ? `drain-merge completed with ${report.conflicts.length} conflicts` : `drain-merge merged ${report.merged.length} branches`],
-		exitCode: hasFailure ? 1 : 0,
+		evidence: drainMergeEvidence(report, options.evidence, hasFailure),
+		exitCode: drainMergeExitCode(hasFailure),
 		output: JSON.stringify(report)
 	};
 }
+function hasDrainMergeFailure(report, failed) {
+	return report.conflicts.length > 0 || failed === true;
+}
+function drainMergeEvidence(report, evidence, hasFailure) {
+	return [...evidence ?? [], drainMergeSummary(report, hasFailure)];
+}
+function drainMergeSummary(report, hasFailure) {
+	return hasFailure ? `drain-merge completed with ${report.conflicts.length} conflicts` : `drain-merge merged ${report.merged.length} branches`;
+}
+function drainMergeExitCode(hasFailure) {
+	return hasFailure ? 1 : 0;
+}
+function drainMergeSetupErrorResult(report, error) {
+	return drainMergeResult(report, {
+		evidence: [`drain-merge setup-error: ${errorMessage(error)}`],
+		failed: true
+	});
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
 //#endregion
 export { executeDrainMergeBuiltin };

package/dist/runtime/gates/gates.js

@@ -1,46 +1,64 @@
 import { isRecord, parseJsonResult } from "../../safe-json.js";
 import { runtimeActorId } from "../actor-ids.js";
-import { executeCommand } from "../command-executor/command-executor.js";
-import "../command-executor/index.js";
 import { readOptionalFile, validateJsonSchemaSource } from "../json-validation/json-validation.js";
 import "../json-validation/index.js";
 import { emitGateFinish, emitGateStart, runtimeSystemId } from "../events/events.js";
 import "../events/index.js";
-import { artifactExists } from "../../gates.js";
+import { CommandExecutor, CommandExecutorLive } from "../services/command-executor-service.js";
 import { executeBuiltin } from "../builtins/builtins.js";
 import "../builtins/index.js";
+import { artifactExists } from "../../gates.js";
+import { Effect } from "effect";
 import { join } from "node:path";
 import micromatch from "micromatch";
 //#region src/runtime/gates/gates.ts
-async function evaluateNodeGates(node, context, attempt, onGateFailure) {
+function evaluateNodeGates(node, context, attempt, onGateFailure) {
+	return Effect.runPromise(Effect.provide(evaluateNodeGatesEffect(node, context, attempt, onGateFailure), CommandExecutorLive));
+}
+function evaluateNodeGatesEffect(node, context, attempt, onGateFailure) {
+	return Effect.gen(function* () {
+		const executor = yield* CommandExecutor;
+		return yield* Effect.tryPromise(() => evaluateNodeGatesWithExecutor(node, context, attempt, executor, onGateFailure));
+	});
+}
+async function evaluateNodeGatesWithExecutor(node, context, attempt, executor, onGateFailure) {
 	const results = [];
-	for (const gate of nodeGateSpecs(node, context)) {
-		const gateId = gate.id ?? `${gate.kind}:${node.id}`;
-		if (isCancelled(context)) {
-			emitRuntimeGateCancelled(context, gate, gateId, node.id, "gate cancelled");
-			break;
-		}
-		emitGateStart(context, node.id, gate, gateId);
-		const result = await runGateEvaluation(gate, gateId, node.id, context, attempt);
-		context.gates.push(result);
-		results.push(result);
-		emitGateFinish(context, gate, result);
-		if (!result.passed) {
-			await onGateFailure?.(node, result);
-			if (gate.required !== false) break;
-		}
-	}
+	for (const gate of nodeGateSpecs(node, context)) if (await evaluateNodeGateIteration(gate, node, context, attempt, executor, results, onGateFailure) === "stop") break;
 	return results;
 }
-async function runGateEvaluation(gate, gateId, nodeId, context, attempt) {
+async function evaluateNodeGateIteration(gate, node, context, attempt, executor, results, onGateFailure) {
+	const gateId = gate.id ?? `${gate.kind}:${node.id}`;
+	if (isCancelled(context)) {
+		emitRuntimeGateCancelled(context, gate, gateId, node.id, "gate cancelled");
+		return "stop";
+	}
+	const result = await runObservedGate(gate, gateId, node.id, context, attempt, executor);
+	recordGateResult(context, gate, result, results);
+	return handleGateFailure(gate, node, result, onGateFailure);
+}
+function runObservedGate(gate, gateId, nodeId, context, attempt, executor) {
+	emitGateStart(context, nodeId, gate, gateId);
+	return runGateEvaluation(gate, gateId, nodeId, context, attempt, executor);
+}
+function recordGateResult(context, gate, result, results) {
+	context.gates.push(result);
+	results.push(result);
+	emitGateFinish(context, gate, result);
+}
+async function handleGateFailure(gate, node, result, onGateFailure) {
+	if (result.passed) return "continue";
+	if (onGateFailure) await onGateFailure(node, result);
+	return gate.required === false ? "continue" : "stop";
+}
+async function runGateEvaluation(gate, gateId, nodeId, context, attempt, executor) {
 	emitRuntimeGateStarted(context, gate, gateId, nodeId);
-	const result = await resolveGateResult(gate, gateId, nodeId, context, attempt);
+	const result = await resolveGateResult(gate, gateId, nodeId, context, attempt, executor);
 	emitRuntimeGateResult(context, result);
 	return result;
 }
-async function resolveGateResult(gate, gateId, nodeId, context, attempt) {
+async function resolveGateResult(gate, gateId, nodeId, context, attempt, executor) {
 	try {
-		return await evaluateGate(gate, nodeId, context, attempt);
+		return await evaluateGate(gate, nodeId, context, attempt, executor);
 	} catch (err) {
 		return {
 			evidence: [err instanceof Error ? err.message : String(err)],
@@ -135,11 +153,11 @@ function schemaGateSpecs(node, context) {
 		target: "stdout"
 	}];
 }
-function evaluateGate(gate, nodeId, context, attempt) {
+function evaluateGate(gate, nodeId, context, attempt, executor) {
 	const gateId = gate.id ?? `${gate.kind}:${nodeId}`;
 	const node = context.plan.graph.node(nodeId);
 	switch (gate.kind) {
-		case "command": return evaluateCommandGate(gate, gateId, nodeId, context);
+		case "command": return evaluateCommandGate(gate, gateId, nodeId, context, executor);
 		case "artifact": return evaluateArtifactGate(gate, gateId, nodeId, context);
 		case "builtin": return evaluateBuiltinGate(gate, gateId, nodeId, context);
 		case "verdict": return evaluateVerdictGate(gate, gateId, nodeId, context, attempt);
@@ -152,8 +170,8 @@ function evaluateGate(gate, nodeId, context, attempt) {
 function assertNever(value) {
 	throw new Error(`Unsupported gate kind: ${String(value)}`);
 }
-async function evaluateCommandGate(gate, gateId, nodeId, context) {
-	const result = await executeCommand(gate.command ?? [], context, { timeout: gate.timeout_ms });
+async function evaluateCommandGate(gate, gateId, nodeId, context, executor) {
+	const result = await Effect.runPromise(executor.execute(gate.command ?? [], context, { timeout: gate.timeout_ms }));
 	const expected = gate.expect_exit_code ?? 0;
 	return {
 		evidence: result.evidence,

package/dist/runtime/hooks/hooks.js

@@ -1,12 +1,12 @@
 import { parseJson } from "../../safe-json.js";
 import { parseHookResult } from "../../hooks.js";
 import { runtimeActorId } from "../actor-ids.js";
-import { executeCommand } from "../command-executor/command-executor.js";
-import "../command-executor/index.js";
 import { validateJsonSchemaSource } from "../json-validation/json-validation.js";
 import "../json-validation/index.js";
 import { emit, runtimeSystemId } from "../events/events.js";
 import "../events/index.js";
+import { CommandExecutor, CommandExecutorLive } from "../services/command-executor-service.js";
+import { Effect } from "effect";
 import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
@@ -225,34 +225,79 @@ function hookModuleSpecifier(hookFunction, context) {
 	if (hookFunction.module.startsWith(".") || hookFunction.module.startsWith("/")) return pathToFileURL(resolve(context.worktreePath, hookFunction.module)).href;
 	return hookFunction.module;
 }
-async function executeCommandHookFunction(hookFunction, binding, event, context, failure, node, gateId) {
-	if (context.hookPolicy.allowCommandHooks === false) return { failure: runtimeHookFailure(binding, `hook '${binding.id}' failed`, ["command hooks are disabled"], node) };
-	if (hookFunction.trusted !== true && (context.config.hooks.policy?.commands === "trusted-only" || context.hookPolicy.allowUntrustedCommandHooks === false)) return { failure: runtimeHookFailure(binding, `hook '${binding.id}' failed`, ["command hook is not trusted"], node) };
-	if (context.config.hooks.policy?.commands === "deny") return { failure: runtimeHookFailure(binding, `hook '${binding.id}' failed`, ["command hooks are disabled"], node) };
-	const tempDir = mkdtempSync(join(tmpdir(), "pipeline-hook-"));
-	const inputPath = join(tempDir, "input.json");
-	const resultPath = join(tempDir, "result.json");
-	try {
-		writeFileSync(inputPath, JSON.stringify(hookContext(context, event, binding, failure, node, gateId)));
-		const commandResult = await executeCommand(hookFunction.command, context, {
-			env: {
-				...hookEnv(hookFunction, context),
-				PIPELINE_HOOK_INPUT: inputPath,
-				PIPELINE_HOOK_RESULT: resultPath
-			},
-			extendEnv: false,
-			outputLimitBytes: hookFunction.output_limit_bytes ?? context.hookPolicy.outputLimitBytes,
-			timeout: hookFunction.timeout_ms ?? context.hookPolicy.timeoutMs
-		});
+function executeCommandHookFunction(hookFunction, binding, event, context, failure, node, gateId) {
+	const program = executeCommandHookFunctionEffect(hookFunction, binding, event, context, failure, node, gateId);
+	return Effect.runPromise(Effect.provide(program, CommandExecutorLive));
+}
+function executeCommandHookFunctionEffect(hookFunction, binding, event, context, failure, node, gateId) {
+	return Effect.gen(function* () {
+		const policyFailure = commandHookPolicyFailure(hookFunction, binding, context, node);
+		if (policyFailure) return { failure: policyFailure };
+		const files = yield* createHookTempFiles();
+		return yield* runCommandHookWithTempFiles(files, hookFunction, binding, event, context, failure, node, gateId).pipe(Effect.ensuring(removeHookTempDir(files.tempDir)));
+	});
+}
+function createHookTempFiles() {
+	return Effect.try(() => {
+		const tempDir = mkdtempSync(join(tmpdir(), "pipeline-hook-"));
+		return {
+			inputPath: join(tempDir, "input.json"),
+			resultPath: join(tempDir, "result.json"),
+			tempDir
+		};
+	});
+}
+function removeHookTempDir(tempDir) {
+	return Effect.sync(() => rmSync(tempDir, {
+		force: true,
+		recursive: true
+	}));
+}
+function commandHookPolicyFailure(hookFunction, binding, context, node) {
+	if (commandHooksDisabled(context)) return commandHookFailure(binding, "command hooks are disabled", node);
+	if (untrustedCommandHookDisabled(hookFunction, context)) return commandHookFailure(binding, "command hook is not trusted", node);
+}
+function commandHooksDisabled(context) {
+	return context.hookPolicy.allowCommandHooks === false || context.config.hooks.policy?.commands === "deny";
+}
+function untrustedCommandHookDisabled(hookFunction, context) {
+	const commandPolicy = context.config.hooks.policy?.commands;
+	return hookFunction.trusted !== true && (commandPolicy === "trusted-only" || context.hookPolicy.allowUntrustedCommandHooks === false);
+}
+function commandHookFailure(binding, evidence, node) {
+	return runtimeHookFailure(binding, `hook '${binding.id}' failed`, [evidence], node);
+}
+function runCommandHookWithTempFiles(files, hookFunction, binding, event, context, failure, node, gateId) {
+	return Effect.gen(function* () {
+		yield* writeCommandHookInput(files.inputPath, hookContext(context, event, binding, failure, node, gateId));
+		const commandResult = yield* (yield* CommandExecutor).execute(hookFunction.command, context, commandHookOptions(hookFunction, context, files));
 		if (commandResult.exitCode !== 0) return { failure: runtimeHookFailure(binding, `hook '${binding.id}' failed`, commandResult.evidence, node) };
-		if (!existsSync(resultPath)) return { failure: runtimeHookFailure(binding, `hook '${binding.id}' failed`, ["command hook did not write PIPELINE_HOOK_RESULT"], node) };
-		return parseAndValidateHookResult(parseJson(readFileSync(resultPath, "utf8"), "hook result"), binding, hookFunction, context, node);
-	} finally {
-		rmSync(tempDir, {
-			force: true,
-			recursive: true
-		});
-	}
+		return yield* readCommandHookResult(files.resultPath, binding, hookFunction, context, node);
+	});
+}
+function writeCommandHookInput(inputPath, context) {
+	return Effect.try(() => writeFileSync(inputPath, JSON.stringify(context)));
+}
+function commandHookOptions(hookFunction, context, files) {
+	return {
+		env: {
+			...hookEnv(hookFunction, context),
+			PIPELINE_HOOK_INPUT: files.inputPath,
+			PIPELINE_HOOK_RESULT: files.resultPath
+		},
+		extendEnv: false,
+		outputLimitBytes: hookFunction.output_limit_bytes ?? context.hookPolicy.outputLimitBytes,
+		timeout: hookFunction.timeout_ms ?? context.hookPolicy.timeoutMs
+	};
+}
+function readCommandHookResult(resultPath, binding, hookFunction, context, node) {
+	return Effect.gen(function* () {
+		if (!(yield* Effect.sync(() => existsSync(resultPath)))) return { failure: commandHookFailure(binding, "command hook did not write PIPELINE_HOOK_RESULT", node) };
+		return yield* parseCommandHookResult(resultPath, binding, hookFunction, context, node);
+	});
+}
+function parseCommandHookResult(resultPath, binding, hookFunction, context, node) {
+	return Effect.try(() => parseAndValidateHookResult(parseJson(readFileSync(resultPath, "utf8"), "hook result"), binding, hookFunction, context, node));
 }
 function hookContext(context, event, binding, failure, node, gateId) {
 	const taskContext = node ? effectiveTaskContext(node, context) : context.taskContext;

package/dist/runtime/opencode-server.js

@@ -1,5 +1,6 @@
-import { Data } from "effect";
-import { createOpencode, createOpencodeClient } from "@opencode-ai/sdk";
+import { OpencodeSdkService, OpencodeSdkServiceLive } from "./services/opencode-sdk-service.js";
+import { Data, Effect } from "effect";
+import { createOpencodeClient } from "@opencode-ai/sdk";
 //#region src/runtime/opencode-server.ts
 const DEFAULT_STARTUP_TIMEOUT_MS = 3e4;
 var OpencodeServerStartupError = class extends Data.TaggedError("OpencodeServerStartupError") {
@@ -10,30 +11,35 @@ var OpencodeServerStartupError = class extends Data.TaggedError("OpencodeServerS
 		});
 	}
 };
-async function openOpencodeServer(options) {
+function openOpencodeServer(options) {
+	return Effect.runPromise(Effect.provide(openOpencodeServerEffect(options), OpencodeSdkServiceLive));
+}
+function openOpencodeServerEffect(options) {
 	const externalUrl = options.serverUrl ?? process.env.OPENCODE_SERVER_URL ?? "";
-	if (externalUrl.length > 0) return connectExternalServer(externalUrl, options.directory);
-	return await spawnOwnedServer(options);
+	if (externalUrl.length > 0) return connectExternalServer(externalUrl, options.directory).pipe(Effect.mapError(startupError));
+	return spawnOwnedServer(options);
 }
 function connectExternalServer(url, directory) {
-	return {
-		close: () => Promise.resolve(),
-		client: createOpencodeClient({
-			baseUrl: url,
-			directory
-		}),
-		owned: false,
-		url
-	};
+	return Effect.gen(function* () {
+		return {
+			close: () => Promise.resolve(),
+			client: yield* (yield* OpencodeSdkService).createClient({
+				baseUrl: url,
+				directory
+			}),
+			owned: false,
+			url
+		};
+	});
 }
-async function spawnOwnedServer(options) {
-	const spawn = options.spawn ?? createOpencode;
-	try {
-		const { client, server } = await spawn(spawnArgs(options));
+function spawnOwnedServer(options) {
+	return Effect.gen(function* () {
+		const { client, server } = yield* (yield* OpencodeSdkService).spawnServer(spawnArgs(options), options.spawn);
 		return ownedHandle(client, server, options.directory);
-	} catch (error) {
-		throw new OpencodeServerStartupError(`Failed to start opencode server: ${errorText(error)}`, { cause: error });
-	}
+	}).pipe(Effect.catchAll((error) => Effect.fail(startupError(error))));
+}
+function startupError(error) {
+	return new OpencodeServerStartupError(`Failed to start opencode server: ${errorText(error)}`, { cause: error });
 }
 function spawnArgs(options) {
 	return {