@oisincoveney/pipeline 2.8.0 → 2.8.2

package/dist/run-state/git-refs.js

@@ -1,14 +1,13 @@
+import { GitPorcelainService, GitPorcelainServiceLive } from "../runtime/services/git-porcelain-service.js";
+import { Effect } from "effect";
 import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { tmpdir } from "node:os";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
 //#region src/run-state/git-refs.ts
 const DEFAULT_WORKSPACE_PATH = "/workspace";
 const DEFAULT_GIT_CREDENTIALS_DIR = "/etc/pipeline/git-credentials";
 const WRITABLE_GIT_CREDENTIAL_STORE = resolve(tmpdir(), "pipeline-git-credentials");
 const SCP_LIKE_SSH_REMOTE_RE = /^[^@\s]+@[^:\s]+:.+/u;
-const execGit = promisify(execFile);
 let preparedBasicAuthCredentialStore;
 function runnerGitRefs(payload, nodeId) {
 	const prefix = `refs/heads/pipeline/runs/${payload.run.id}/${payload.workflow.id}`;
@@ -19,101 +18,132 @@ function runnerGitRefs(payload, nodeId) {
 	};
 }
 async function prepareRunnerGitWorkspace(payload, options = {}) {
-	if (options.cwd) return resolve(options.cwd);
-	const worktreePath = options.workspacePath ?? DEFAULT_WORKSPACE_PATH;
-	mkdirSync(dirname(worktreePath), { recursive: true });
-	await runGit(dirname(worktreePath), [
-		"clone",
-		"--no-tags",
-		payload.repository.url,
-		worktreePath
-	]);
-	await runGit(worktreePath, ["checkout", payload.repository.sha ?? `origin/${payload.repository.baseBranch}`]);
-	return worktreePath;
+	return await Effect.runPromise(Effect.provide(prepareRunnerGitWorkspaceEffect(payload, options), GitPorcelainServiceLive));
+}
+function prepareRunnerGitWorkspaceEffect(payload, options) {
+	return Effect.gen(function* () {
+		if (options.cwd) return resolve(options.cwd);
+		const worktreePath = options.workspacePath ?? DEFAULT_WORKSPACE_PATH;
+		yield* Effect.sync(() => mkdirSync(dirname(worktreePath), { recursive: true }));
+		yield* runGit(dirname(worktreePath), [
+			"clone",
+			"--no-tags",
+			payload.repository.url,
+			worktreePath
+		]);
+		yield* runGit(worktreePath, ["checkout", payload.repository.sha ?? `origin/${payload.repository.baseBranch}`]);
+		return worktreePath;
+	});
 }
 async function mergeDependencyRefs(input) {
-	await configureGitCommitter(input.worktreePath, input.committer);
-	for (const nodeId of input.dependencyNodeIds) {
-		const ref = runnerGitRefs(input.payload, nodeId).nodeRef;
-		await runGit(input.worktreePath, [
+	return await Effect.runPromise(Effect.provide(mergeDependencyRefsEffect(input), GitPorcelainServiceLive));
+}
+function mergeDependencyRefsEffect(input) {
+	return Effect.gen(function* () {
+		yield* configureGitCommitter(input.worktreePath, input.committer);
+		yield* Effect.forEach(input.dependencyNodeIds, (nodeId) => mergeDependencyRef(input.worktreePath, runnerGitRefs(input.payload, nodeId).nodeRef));
+	});
+}
+function mergeDependencyRef(worktreePath, ref) {
+	return Effect.gen(function* () {
+		yield* runGit(worktreePath, [
 			"fetch",
 			"origin",
 			ref
 		]);
-		await runGit(input.worktreePath, [
+		yield* runGit(worktreePath, [
 			"merge",
 			"--no-ff",
 			"--no-edit",
 			"FETCH_HEAD"
 		]);
-	}
+	});
 }
 async function commitAndPushNodeRef(input) {
-	await commitChangesIfNeeded(input.worktreePath, input.nodeId, input.committer);
-	const sha = (await runGit(input.worktreePath, ["rev-parse", "HEAD"])).trim();
-	await runGit(input.worktreePath, [
-		"push",
-		"origin",
-		`HEAD:${runnerGitRefs(input.payload, input.nodeId).nodeRef}`
-	]);
-	return sha;
+	return await Effect.runPromise(Effect.provide(commitAndPushNodeRefEffect(input), GitPorcelainServiceLive));
+}
+function commitAndPushNodeRefEffect(input) {
+	return Effect.gen(function* () {
+		yield* commitChangesIfNeeded(input.worktreePath, input.nodeId, input.committer);
+		const sha = yield* headSha(input.worktreePath);
+		yield* runGit(input.worktreePath, [
+			"push",
+			"origin",
+			`HEAD:${runnerGitRefs(input.payload, input.nodeId).nodeRef}`
+		]);
+		return sha;
+	});
 }
 async function promoteFinalRef(input) {
-	await mergeDependencyRefs({
-		committer: input.committer,
-		dependencyNodeIds: input.sourceNodeIds,
-		payload: input.payload,
-		worktreePath: input.worktreePath
+	return await Effect.runPromise(Effect.provide(promoteFinalRefEffect(input), GitPorcelainServiceLive));
+}
+function promoteFinalRefEffect(input) {
+	return Effect.gen(function* () {
+		yield* mergeDependencyRefsEffect({
+			committer: input.committer,
+			dependencyNodeIds: input.sourceNodeIds,
+			payload: input.payload,
+			worktreePath: input.worktreePath
+		});
+		yield* commitChangesIfNeeded(input.worktreePath, "final", input.committer);
+		const sha = yield* headSha(input.worktreePath);
+		yield* runGit(input.worktreePath, [
+			"push",
+			"origin",
+			`HEAD:${runnerGitRefs(input.payload, "final").finalRef}`
+		]);
+		return sha;
+	});
+}
+function headSha(worktreePath) {
+	return Effect.map(runGit(worktreePath, ["rev-parse", "HEAD"]), (sha) => sha.trim());
+}
+function commitChangesIfNeeded(worktreePath, nodeId, committer) {
+	return Effect.gen(function* () {
+		if ((yield* runGit(worktreePath, [
+			"status",
+			"--porcelain",
+			"--untracked-files=all"
+		])).trim().length === 0) return;
+		yield* runGit(worktreePath, ["add", "--all"]);
+		yield* configureGitCommitter(worktreePath, committer);
+		yield* runGit(worktreePath, [
+			"commit",
+			"-m",
+			`pipeline: ${nodeId}`
+		]);
+	});
+}
+function configureGitCommitter(worktreePath, committer) {
+	return Effect.gen(function* () {
+		yield* runGit(worktreePath, [
+			"config",
+			"--local",
+			"user.name",
+			committer.name
+		]);
+		yield* runGit(worktreePath, [
+			"config",
+			"--local",
+			"user.email",
+			committer.email
+		]);
 	});
-	await commitChangesIfNeeded(input.worktreePath, "final", input.committer);
-	const sha = (await runGit(input.worktreePath, ["rev-parse", "HEAD"])).trim();
-	await runGit(input.worktreePath, [
-		"push",
-		"origin",
-		`HEAD:${runnerGitRefs(input.payload, "final").finalRef}`
-	]);
-	return sha;
-}
-async function commitChangesIfNeeded(worktreePath, nodeId, committer) {
-	if ((await runGit(worktreePath, [
-		"status",
-		"--porcelain",
-		"--untracked-files=all"
-	])).trim().length === 0) return;
-	await runGit(worktreePath, ["add", "--all"]);
-	await configureGitCommitter(worktreePath, committer);
-	await runGit(worktreePath, [
-		"commit",
-		"-m",
-		`pipeline: ${nodeId}`
-	]);
-}
-async function configureGitCommitter(worktreePath, committer) {
-	await runGit(worktreePath, [
-		"config",
-		"--local",
-		"user.name",
-		committer.name
-	]);
-	await runGit(worktreePath, [
-		"config",
-		"--local",
-		"user.email",
-		committer.email
-	]);
 }
 function runnerGitCommandArgs(args, remoteUrl) {
 	return [...gitCredentialConfigArgs(remoteUrl), ...args];
 }
-async function runGit(cwd, args) {
-	const remoteUrl = await remoteUrlFromGitArgs(cwd, args);
-	assertSshCredentialsAvailable(remoteUrl);
-	const { stdout } = await execGit("git", runnerGitCommandArgs(args, remoteUrl), {
-		cwd,
-		encoding: "utf8",
-		env: runnerGitEnv(remoteUrl)
+function runGit(cwd, args) {
+	return Effect.gen(function* () {
+		const remoteUrl = yield* remoteUrlFromGitArgs(cwd, args);
+		yield* Effect.try({
+			try: () => assertSshCredentialsAvailable(remoteUrl),
+			catch: (error) => error
+		});
+		const git = yield* GitPorcelainService;
+		const commandArgs = runnerGitCommandArgs(args, remoteUrl);
+		return yield* git.run(cwd, commandArgs, runnerGitEnv(remoteUrl));
 	});
-	return stdout;
 }
 function assertSshCredentialsAvailable(remoteUrl) {
 	if (!(remoteUrl && isSshRemote(remoteUrl))) return;
@@ -227,12 +257,15 @@ function isOwnerReadOnly(path) {
 function readCredentialFile(path) {
 	return readFileSync(path, "utf8").trim();
 }
-async function remoteUrlFromGitArgs(cwd, args) {
-	const literalRemoteUrl = literalRemoteUrlFromGitArgs(args);
-	if (literalRemoteUrl) return literalRemoteUrl;
-	const remoteName = remoteNameFromGitArgs(args);
-	if (!remoteName) return;
-	return await gitRemoteUrl(cwd, remoteName);
+function remoteUrlFromGitArgs(cwd, args) {
+	return Effect.gen(function* () {
+		const literalRemoteUrl = literalRemoteUrlFromGitArgs(args);
+		if (literalRemoteUrl) return literalRemoteUrl;
+		return yield* remoteUrlForName(cwd, remoteNameFromGitArgs(args));
+	});
+}
+function remoteUrlForName(cwd, remoteName) {
+	return remoteName ? gitRemoteUrl(cwd, remoteName) : Effect.succeed(void 0);
 }
 function literalRemoteUrlFromGitArgs(args) {
 	if (args[0] === "clone") return args.find((arg) => isRemoteUrl(arg));
@@ -247,20 +280,17 @@ function remoteNameFromGitArgs(args) {
 		if (remoteArg && !remoteArg.startsWith("-") && !isRemoteUrl(remoteArg)) return remoteArg;
 	}
 }
-async function gitRemoteUrl(cwd, remoteName) {
-	const { stdout } = await execGit("git", [
-		"remote",
-		"get-url",
-		remoteName
-	], {
-		cwd,
-		encoding: "utf8",
-		env: {
+function gitRemoteUrl(cwd, remoteName) {
+	return Effect.gen(function* () {
+		return (yield* (yield* GitPorcelainService).run(cwd, [
+			"remote",
+			"get-url",
+			remoteName
+		], {
 			...process.env,
 			GIT_TERMINAL_PROMPT: "0"
-		}
+		})).trim() || void 0;
 	});
-	return stdout.trim() || void 0;
 }
 function isRemoteUrl(value) {
 	return value.startsWith("http://") || value.startsWith("https://") || value.startsWith("ssh://") || isScpLikeSshRemote(value);

package/dist/runner-command-contract.d.ts

@@ -43,8 +43,8 @@ declare const runnerDeliverySchema: z.ZodObject<{
 declare const mokaSubmissionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   kind: z.ZodLiteral<"graph">;
   mode: z.ZodEnum<{
-    quick: "quick";
     full: "full";
+    quick: "quick";
   }>;
 }, z.core.$strict>, z.ZodObject<{
   argv: z.ZodArray<z.ZodString>;
@@ -104,8 +104,8 @@ declare const runnerCommandPayloadSchema: z.ZodObject<{
   submission: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"graph">;
     mode: z.ZodEnum<{
-      quick: "quick";
       full: "full";
+      quick: "quick";
     }>;
   }, z.core.$strict>, z.ZodObject<{
     argv: z.ZodArray<z.ZodString>;

package/dist/runner-event-sink.js

@@ -1,39 +1,14 @@
 import { mapRuntimeEventToRunnerEventRecords } from "./runner-command-contract.js";
-import { Data } from "effect";
-import ky, { isHTTPError } from "ky";
+import { RunnerEventSinkHttpService, RunnerEventSinkHttpServiceLive } from "./runtime/services/runner-event-sink-http-service.js";
+import { Effect } from "effect";
 //#region src/runner-event-sink.ts
 const DEFAULT_BATCH_SIZE = 50;
 const DEFAULT_MAX_RETRIES = 0;
 const DEFAULT_RETRY_DELAY_MS = 250;
-const RETRYABLE_STATUS_CODES = [
-	408,
-	429,
-	500,
-	501,
-	502,
-	503,
-	504,
-	505,
-	506,
-	507,
-	508,
-	509,
-	510,
-	511
-];
-var EventSinkHttpError = class extends Data.TaggedError("EventSinkHttpError") {
-	constructor(status, message) {
-		super({
-			status,
-			message
-		});
-	}
-};
 function createRunnerEventSink(options) {
-	const batchSize = Math.max(1, options.batchSize ?? DEFAULT_BATCH_SIZE);
-	const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
-	if (!fetchImpl) throw new Error("Runner event sink requires fetch support");
-	if (!options.authToken.trim()) throw new Error("Runner event sink requires an auth token");
+	const batchSize = positiveOrDefault(options.batchSize, DEFAULT_BATCH_SIZE);
+	const fetchImpl = resolveFetch(options.fetch);
+	assertAuthToken(options.authToken);
 	const queue = [];
 	let flushChain = Promise.resolve();
 	let nextSequence = 1;
@@ -46,15 +21,17 @@ function createRunnerEventSink(options) {
 			sequence
 		};
 	};
-	const flushQueue = async () => {
-		while (queue.length > 0) {
+	const flushQueueEffect = () => Effect.gen(function* () {
+		const service = yield* RunnerEventSinkHttpService;
+		while (hasQueuedEvents(queue)) {
 			const batch = queue.slice(0, batchSize);
-			await postBatch(options, fetchImpl, batch);
+			yield* service.postBatch(postBatchRequest(options, fetchImpl, batch));
 			queue.splice(0, batch.length);
 		}
-	};
+	});
+	const runFlush = () => Effect.runPromise(Effect.provide(flushQueueEffect(), RunnerEventSinkHttpServiceLive));
 	const runSerializedFlush = () => {
-		const nextFlush = flushChain.then(flushQueue, flushQueue);
+		const nextFlush = flushChain.then(runFlush, runFlush);
 		flushChain = nextFlush.catch(() => void 0);
 		return nextFlush;
 	};
@@ -145,41 +122,32 @@ function createRunnerEventSink(options) {
 		}
 	};
 }
-async function postBatch(options, fetchImpl, events) {
-	const maxRetries = Math.max(0, options.maxRetries ?? DEFAULT_MAX_RETRIES);
-	const retryDelayMs = Math.max(0, options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS);
-	try {
-		await ky.post(options.url, {
-			fetch: kyFetchAdapter(fetchImpl),
-			headers: { [options.authHeader ?? "Authorization"]: `Bearer ${options.authToken}` },
-			json: { events },
-			retry: {
-				delay: () => retryDelayMs,
-				limit: maxRetries,
-				methods: ["post"],
-				retryOnTimeout: true,
-				statusCodes: RETRYABLE_STATUS_CODES
-			}
-		});
-	} catch (err) {
-		if (isHTTPError(err)) {
-			let data = "";
-			if (typeof err.data === "string") data = err.data;
-			else if (err.data !== void 0) data = JSON.stringify(err.data);
-			throw new EventSinkHttpError(err.response.status, `Event sink responded with ${err.response.status}${data ? `: ${data}` : ""}`);
-		}
-		throw err instanceof Error ? err : new Error(String(err));
-	}
+function hasQueuedEvents(queue) {
+	return queue.length > 0;
 }
-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 positiveOrDefault(value, fallback) {
+	return Math.max(1, value ?? fallback);
+}
+function nonNegativeOrDefault(value, fallback) {
+	return Math.max(0, value ?? fallback);
+}
+function resolveFetch(fetchImpl) {
+	const resolved = fetchImpl ?? globalThis.fetch?.bind(globalThis);
+	if (!resolved) throw new Error("Runner event sink requires fetch support");
+	return resolved;
+}
+function assertAuthToken(authToken) {
+	if (!authToken.trim()) throw new Error("Runner event sink requires an auth token");
+}
+function postBatchRequest(options, fetchImpl, events) {
+	return {
+		authHeader: options.authHeader,
+		authToken: options.authToken,
+		events,
+		fetch: fetchImpl,
+		maxRetries: nonNegativeOrDefault(options.maxRetries, DEFAULT_MAX_RETRIES),
+		retryDelayMs: nonNegativeOrDefault(options.retryDelayMs, DEFAULT_RETRY_DELAY_MS),
+		url: options.url
 	};
 }
 function timestamp(now) {