@oisincoveney/pipeline 2.8.4 → 2.9.0

package/dist/runner-command/finalize.js

@@ -1,11 +1,12 @@
 import { compileArgoExecutionGraph } from "../argo-graph.js";
-import { RunnerCommandPayloadValidationError } from "../runner-command-contract.js";
-import { promoteFinalRef } from "../run-state/git-refs.js";
 import { dispatchHooks } from "../runtime/hooks/hooks.js";
 import "../runtime/hooks/index.js";
 import { finalizeWorkflowLifecycle } from "../runtime/workflow-lifecycle.js";
-import { createRunnerLifecycleContext } from "./lifecycle-context.js";
+import { RunnerCommandPayloadValidationError } from "../runner-command-contract.js";
+import { RunnerCommandIoService, flushAndReport, isOutputStream, runValidatedRunnerCommand } from "../runtime/services/runner-command-io-service.js";
+import { createRunnerLifecycleContextEffect } from "./lifecycle-context.js";
 import { z } from "zod";
+import { Effect } from "effect";
 //#region src/runner-command/finalize.ts
 const runnerFinalizeOptionsSchema = z.object({
 	argoStatus: z.string().min(1),
@@ -20,26 +21,26 @@ const EXIT_PASS = 0;
 const EXIT_FAIL = 1;
 const EXIT_VALIDATION = 64;
 const EXIT_STARTUP = 70;
-async function runRunnerFinalize(rawOptions = {}) {
-	const parsedOptions = runnerFinalizeOptionsSchema.safeParse(rawOptions);
-	const stderr = rawOptions.stderr ?? process.stderr;
-	if (!parsedOptions.success) {
-		stderr.write(`${parsedOptions.error.message}\n`);
-		return EXIT_VALIDATION;
-	}
-	const options = parsedOptions.data;
-	try {
-		const { compiled, context, payload, sink, worktreePath } = await createRunnerLifecycleContext(options);
-		const lifecycle = await finalizeWorkflowLifecycle({
-			buildResult: (outcome, nodes, failure) => runnerFinalizeRuntimeResult(context, outcome, nodes, failure),
-			runWorkflowHook: (event, failure) => dispatchHooks(context, event, failure)
-		}, {
-			completed: [],
-			outcome: options.argoStatus === "Succeeded" ? "PASS" : "FAIL"
+function runRunnerFinalize(rawOptions = {}) {
+	return runValidatedRunnerCommand(runnerFinalizeOptionsSchema, rawOptions, runRunnerFinalizeEffect);
+}
+function runRunnerFinalizeEffect(options, stderr) {
+	return Effect.gen(function* () {
+		const io = yield* RunnerCommandIoService;
+		const { compiled, context, payload, sink, worktreePath } = yield* createRunnerLifecycleContextEffect(options);
+		const lifecycle = yield* Effect.tryPromise({
+			try: () => finalizeWorkflowLifecycle({
+				buildResult: (outcome, nodes, failure) => runnerFinalizeRuntimeResult(context, outcome, nodes, failure),
+				runWorkflowHook: (event, failure) => dispatchHooks(context, event, failure)
+			}, {
+				completed: [],
+				outcome: options.argoStatus === "Succeeded" ? "PASS" : "FAIL"
+			}),
+			catch: (error) => error
 		});
 		if (lifecycle.result.outcome === "PASS") {
 			const graph = compileArgoExecutionGraph(compiled.plan);
-			await promoteFinalRef({
+			yield* io.promoteFinalRef({
 				committer: compiled.config.runner_command.git.committer,
 				payload,
 				sourceNodeIds: graph.terminalNodeIds,
@@ -47,13 +48,14 @@ async function runRunnerFinalize(rawOptions = {}) {
 			});
 		}
 		sink.recordFinalResult(lifecycle.result.outcome, payload.workflow.id);
-		await flushAndReport(sink, stderr);
+		yield* flushAndReport(sink, stderr);
 		return lifecycle.result.outcome === "PASS" ? EXIT_PASS : EXIT_FAIL;
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		stderr.write(`${message}\n`);
-		return error instanceof RunnerCommandPayloadValidationError || error instanceof z.ZodError ? EXIT_VALIDATION : EXIT_STARTUP;
-	}
+	}).pipe(Effect.catchAll((error) => Effect.sync(() => finalizeErrorExitCode(error, stderr))));
+}
+function finalizeErrorExitCode(error, stderr) {
+	const message = error instanceof Error ? error.message : String(error);
+	stderr.write(`${message}\n`);
+	return error instanceof RunnerCommandPayloadValidationError || error instanceof z.ZodError ? EXIT_VALIDATION : EXIT_STARTUP;
 }
 function runnerFinalizeRuntimeResult(context, outcome, nodes, failure) {
 	return {
@@ -68,16 +70,5 @@ function runnerFinalizeRuntimeResult(context, outcome, nodes, failure) {
 		structuredOutputs: context.nodeStateStore.structuredOutputList()
 	};
 }
-function isOutputStream(value) {
-	return typeof value === "object" && value !== null && "write" in value && typeof value.write === "function";
-}
-async function flushAndReport(sink, stderr) {
-	try {
-		await sink.flush();
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		stderr.write(`runner event flush failed: ${message}\n`);
-	}
-}
 //#endregion
 export { runRunnerFinalize };

package/dist/runner-command/lifecycle-context.js

@@ -1,75 +1,142 @@
 import { PIPELINE_CONFIG_PATH, PROFILES_CONFIG_PATH, RUNNERS_CONFIG_PATH } from "../config/defaults.js";
 import { loadPipelineConfig, parsePipelineConfigParts } from "../config/load.js";
 import "../config.js";
-import { compileScheduleArtifact, parseScheduleArtifact } from "../planning/generate.js";
-import { parseRunnerCommandPayload, resolveRunnerEventSinkAuthToken } from "../runner-command-contract.js";
-import { prepareRunnerGitWorkspace } from "../run-state/git-refs.js";
-import { createRunnerEventSink } from "../runner-event-sink.js";
 import { initialNodeStateStore } from "../runtime/node-state-store.js";
-import { runnerTaskText } from "./run.js";
-import { existsSync, readFileSync } from "node:fs";
+import { parseRunnerCommandPayload } from "../runner-command-contract.js";
+import { RunnerCommandIoService, createRunnerCommandEventSink } from "../runtime/services/runner-command-io-service.js";
+import { compileScheduleArtifact, parseScheduleArtifact } from "../planning/generate.js";
+import { runnerTaskTextEffect } from "./run.js";
+import { Effect } from "effect";
 import { join } from "node:path";
 //#region src/runner-command/lifecycle-context.ts
-async function createRunnerLifecycleContext(options) {
-	const payload = parseRunnerCommandPayload(readFileSync(options.payloadFile, "utf8"));
-	const authToken = resolveRunnerEventSinkAuthToken({ authTokenFile: payload.events.authTokenFile });
-	const sink = createRunnerEventSink({
-		authHeader: payload.events.authHeader,
-		authToken,
-		fetch: options.fetch,
-		runId: payload.run.id,
-		url: payload.events.url
-	});
-	const worktreePath = await prepareRunnerGitWorkspace(payload, { cwd: options.cwd });
-	const compiled = compileScheduleArtifact(loadRunnerLifecycleConfig(worktreePath), parseScheduleArtifact(readFileSync(options.scheduleFile, "utf8"), options.scheduleFile), worktreePath);
-	if (payload.workflow.id !== compiled.workflowId) throw new Error(`Runner payload workflow '${payload.workflow.id}' does not match schedule workflow '${compiled.workflowId}'`);
-	return {
-		compiled,
-		context: {
-			agentInvocations: [],
-			config: compiled.config,
-			executor: () => ({
-				exitCode: 0,
-				stdout: ""
+function createRunnerLifecycleContextEffect(options) {
+	return Effect.gen(function* () {
+		const payload = yield* readRunnerPayloadEffect(options.payloadFile);
+		const sink = createRunnerCommandEventSink({
+			fetch: options.fetch,
+			payload
+		});
+		const worktreePath = yield* prepareRunnerWorktreeEffect(payload, options.cwd);
+		const compiled = yield* compileRunnerScheduleEffect(yield* loadRunnerLifecycleConfigEffect(worktreePath), options.scheduleFile, worktreePath);
+		yield* assertWorkflowIdsMatch(payload.workflow.id, compiled.workflowId);
+		return {
+			compiled,
+			context: buildRunnerRuntimeContext({
+				compiled,
+				payload,
+				sink,
+				task: yield* runnerTaskTextEffect(payload.task, worktreePath),
+				worktreePath
 			}),
-			gates: [],
-			hookFailures: [],
-			hookPolicy: {
-				allowCommandHooks: payload.hookPolicy?.allowCommandHooks ?? true,
-				allowUntrustedCommandHooks: payload.hookPolicy?.allowUntrustedCommandHooks ?? true,
-				env: payload.hookPolicy?.env ?? {},
-				envPassthrough: payload.hookPolicy?.envPassthrough ?? ["PATH"],
-				outputLimitBytes: payload.hookPolicy?.outputLimitBytes ?? 64 * 1024,
-				timeoutMs: payload.hookPolicy?.timeoutMs ?? 3e4
-			},
-			hookResults: /* @__PURE__ */ new Map(),
-			nodeStateStore: initialNodeStateStore(compiled.plan),
-			plan: compiled.plan,
-			reporter: (event) => sink.recordRuntimeEvent(event),
-			runId: payload.run.id,
-			task: runnerTaskText(payload.task, worktreePath),
-			workflowId: compiled.workflowId,
+			payload,
+			sink,
 			worktreePath
-		},
-		payload,
-		sink,
-		worktreePath
+		};
+	});
+}
+function readRunnerPayloadEffect(payloadFile) {
+	return Effect.gen(function* () {
+		const payloadRaw = yield* (yield* RunnerCommandIoService).readText(payloadFile);
+		return yield* attemptSync(() => parseRunnerCommandPayload(payloadRaw));
+	});
+}
+function prepareRunnerWorktreeEffect(payload, cwd) {
+	return Effect.gen(function* () {
+		return yield* (yield* RunnerCommandIoService).prepareRunnerGitWorkspace(payload, { cwd });
+	});
+}
+function compileRunnerScheduleEffect(config, scheduleFile, worktreePath) {
+	return Effect.gen(function* () {
+		const scheduleRaw = yield* (yield* RunnerCommandIoService).readText(scheduleFile);
+		return yield* attemptSync(() => compileScheduleArtifact(config, parseScheduleArtifact(scheduleRaw, scheduleFile), worktreePath));
+	});
+}
+function assertWorkflowIdsMatch(payloadWorkflowId, scheduleWorkflowId) {
+	if (payloadWorkflowId === scheduleWorkflowId) return Effect.void;
+	return Effect.fail(/* @__PURE__ */ new Error(`Runner payload workflow '${payloadWorkflowId}' does not match schedule workflow '${scheduleWorkflowId}'`));
+}
+function buildRunnerRuntimeContext(options) {
+	return {
+		agentInvocations: [],
+		config: options.compiled.config,
+		executor: () => ({
+			exitCode: 0,
+			stdout: ""
+		}),
+		gates: [],
+		hookFailures: [],
+		hookPolicy: runnerHookPolicy(options.payload),
+		hookResults: /* @__PURE__ */ new Map(),
+		nodeStateStore: initialNodeStateStore(options.compiled.plan),
+		plan: options.compiled.plan,
+		reporter: (event) => options.sink.recordRuntimeEvent(event),
+		runId: options.payload.run.id,
+		task: options.task,
+		workflowId: options.compiled.workflowId,
+		worktreePath: options.worktreePath
+	};
+}
+function runnerHookPolicy(payload) {
+	const { allowCommandHooks = true, allowUntrustedCommandHooks = true, env = {}, envPassthrough = ["PATH"], outputLimitBytes = 64 * 1024, timeoutMs = 3e4 } = payload.hookPolicy ?? {};
+	return {
+		allowCommandHooks,
+		allowUntrustedCommandHooks,
+		env,
+		envPassthrough,
+		outputLimitBytes,
+		timeoutMs
 	};
 }
-function loadRunnerLifecycleConfig(worktreePath) {
-	const pipelinePath = join(worktreePath, PIPELINE_CONFIG_PATH);
-	const profilesPath = join(worktreePath, PROFILES_CONFIG_PATH);
-	const runnersPath = join(worktreePath, RUNNERS_CONFIG_PATH);
-	if (existsSync(pipelinePath) && existsSync(profilesPath) && existsSync(runnersPath)) return parsePipelineConfigParts({
-		pipeline: readFileSync(pipelinePath, "utf8"),
-		profiles: readFileSync(profilesPath, "utf8"),
-		runners: readFileSync(runnersPath, "utf8")
-	}, worktreePath, {
-		pipeline: PIPELINE_CONFIG_PATH,
-		profiles: PROFILES_CONFIG_PATH,
-		runners: RUNNERS_CONFIG_PATH
-	}, { allowMissingLintFileReferences: true });
-	return loadPipelineConfig(worktreePath, { allowMissingLintFileReferences: true });
+function loadRunnerLifecycleConfigEffect(worktreePath) {
+	return Effect.gen(function* () {
+		const pipelinePath = join(worktreePath, PIPELINE_CONFIG_PATH);
+		const profilesPath = join(worktreePath, PROFILES_CONFIG_PATH);
+		const runnersPath = join(worktreePath, RUNNERS_CONFIG_PATH);
+		if (yield* hasRunnerLifecycleConfigParts([
+			pipelinePath,
+			profilesPath,
+			runnersPath
+		])) {
+			const parts = yield* readRunnerLifecycleConfigParts({
+				pipelinePath,
+				profilesPath,
+				runnersPath
+			});
+			return yield* attemptSync(() => parsePipelineConfigParts({
+				pipeline: parts.pipeline,
+				profiles: parts.profiles,
+				runners: parts.runners
+			}, worktreePath, {
+				pipeline: PIPELINE_CONFIG_PATH,
+				profiles: PROFILES_CONFIG_PATH,
+				runners: RUNNERS_CONFIG_PATH
+			}, { allowMissingLintFileReferences: true }));
+		}
+		return yield* attemptSync(() => loadPipelineConfig(worktreePath, { allowMissingLintFileReferences: true }));
+	});
+}
+function hasRunnerLifecycleConfigParts(paths) {
+	return Effect.gen(function* () {
+		const io = yield* RunnerCommandIoService;
+		for (const path of paths) if (!(yield* io.exists(path))) return false;
+		return true;
+	});
+}
+function readRunnerLifecycleConfigParts(paths) {
+	return Effect.gen(function* () {
+		const io = yield* RunnerCommandIoService;
+		return {
+			pipeline: yield* io.readText(paths.pipelinePath),
+			profiles: yield* io.readText(paths.profilesPath),
+			runners: yield* io.readText(paths.runnersPath)
+		};
+	});
+}
+function attemptSync(try_) {
+	return Effect.try({
+		try: try_,
+		catch: (error) => error
+	});
 }
 //#endregion
-export { createRunnerLifecycleContext };
+export { createRunnerLifecycleContextEffect };

package/dist/runner-command/lifecycle.js

@@ -2,8 +2,10 @@ import { emitWorkflowPlanned, emitWorkflowStarted } from "../runtime/events/even
 import { dispatchHooks } from "../runtime/hooks/hooks.js";
 import "../runtime/hooks/index.js";
 import { runWorkflowStartLifecycle } from "../runtime/workflow-lifecycle.js";
-import { createRunnerLifecycleContext } from "./lifecycle-context.js";
+import { flushAndReport, isOutputStream, runValidatedRunnerCommand } from "../runtime/services/runner-command-io-service.js";
+import { createRunnerLifecycleContextEffect } from "./lifecycle-context.js";
 import { z } from "zod";
+import { Effect } from "effect";
 //#region src/runner-command/lifecycle.ts
 const runnerLifecycleOptionsSchema = z.object({
 	cwd: z.string().min(1).optional(),
@@ -17,39 +19,28 @@ const EXIT_PASS = 0;
 const EXIT_FAIL = 1;
 const EXIT_VALIDATION = 64;
 const EXIT_STARTUP = 70;
-async function runRunnerLifecycle(rawOptions = {}) {
-	const parsedOptions = runnerLifecycleOptionsSchema.safeParse(rawOptions);
-	const stderr = rawOptions.stderr ?? process.stderr;
-	if (!parsedOptions.success) {
-		stderr.write(`${parsedOptions.error.message}\n`);
-		return EXIT_VALIDATION;
-	}
-	const options = parsedOptions.data;
-	try {
-		const { context, sink } = await createRunnerLifecycleContext(options);
-		const failure = await runWorkflowStartLifecycle({
-			emitWorkflowPlanned: () => emitWorkflowPlanned(context),
-			emitWorkflowStarted: () => emitWorkflowStarted(context),
-			runWorkflowHook: (event) => dispatchHooks(context, event)
+function runRunnerLifecycle(rawOptions = {}) {
+	return runValidatedRunnerCommand(runnerLifecycleOptionsSchema, rawOptions, runRunnerLifecycleEffect);
+}
+function runRunnerLifecycleEffect(options, stderr) {
+	return Effect.gen(function* () {
+		const { context, sink } = yield* createRunnerLifecycleContextEffect(options);
+		const failure = yield* Effect.tryPromise({
+			try: () => runWorkflowStartLifecycle({
+				emitWorkflowPlanned: () => emitWorkflowPlanned(context),
+				emitWorkflowStarted: () => emitWorkflowStarted(context),
+				runWorkflowHook: (event) => dispatchHooks(context, event)
+			}),
+			catch: (error) => error
 		});
-		await flushAndReport(sink, stderr);
+		yield* flushAndReport(sink, stderr);
 		return failure ? EXIT_FAIL : EXIT_PASS;
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		stderr.write(`${message}\n`);
-		return error instanceof z.ZodError ? EXIT_VALIDATION : EXIT_STARTUP;
-	}
-}
-function isOutputStream(value) {
-	return typeof value === "object" && value !== null && "write" in value && typeof value.write === "function";
+	}).pipe(Effect.catchAll((error) => Effect.sync(() => lifecycleErrorExitCode(error, stderr))));
 }
-async function flushAndReport(sink, stderr) {
-	try {
-		await sink.flush();
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		stderr.write(`runner event flush failed: ${message}\n`);
-	}
+function lifecycleErrorExitCode(error, stderr) {
+	const message = error instanceof Error ? error.message : String(error);
+	stderr.write(`${message}\n`);
+	return error instanceof z.ZodError ? EXIT_VALIDATION : EXIT_STARTUP;
 }
 //#endregion
 export { runRunnerLifecycle };