@oisincoveney/pipeline 2.8.0 → 2.8.1

package/dist/argo-submit.d.ts

@@ -1,7 +1,7 @@
 import { PipelineConfig } from "./config/schemas.js";
+import { CoreApi, KubernetesArgoIoDependencies, WorkflowApi } from "./runtime/services/kubernetes-argo-service.js";
 import { workflowSubmitResultSchema } from "./workflow-submit-contract.js";
 import { z } from "zod";
-import { CoreV1Api, CustomObjectsApi, KubeConfig } from "@kubernetes/client-node";
 
 //#region src/argo-submit.d.ts
 declare const submitRunnerArgoWorkflowOptionsSchema: z.ZodObject<{
@@ -36,11 +36,9 @@ type SubmitRunnerArgoWorkflowOptions = z.input<typeof submitRunnerArgoWorkflowOp
 };
 type SubmitRunnerArgoWorkflowResult = z.infer<typeof workflowSubmitResultSchema>;
 type CommandScheduleOptions = z.input<typeof commandScheduleOptionsSchema>;
-type CoreApi = Pick<CoreV1Api, "createNamespacedConfigMap">;
-type WorkflowApi = Pick<CustomObjectsApi, "createNamespacedCustomObject">;
 interface SubmitRunnerArgoWorkflowDependencies {
   coreApi?: CoreApi;
-  kubeConfig?: KubeConfig;
+  kubeConfig?: KubernetesArgoIoDependencies["kubeConfig"];
   workflowApi?: WorkflowApi;
 }
 declare function submitRunnerArgoWorkflow(rawOptions: SubmitRunnerArgoWorkflowOptions, dependencies?: SubmitRunnerArgoWorkflowDependencies): Promise<SubmitRunnerArgoWorkflowResult>;

package/dist/argo-submit.js

@@ -4,11 +4,12 @@ import { buildRunnerArgoWorkflowManifest, runnerArgoWorkflowManifestSchema } fro
 import { normalizeRunnerRepositoryForSubmit } from "./git-remote-url.js";
 import { compileScheduleArtifact, parseScheduleArtifact } from "./planning/generate.js";
 import { parseRunnerCommandPayload, runnerCommandPayloadSchema } from "./runner-command-contract.js";
+import { KubernetesArgoService, KubernetesArgoServiceLive } from "./runtime/services/kubernetes-argo-service.js";
 import { workflowSubmitResultSchema } from "./workflow-submit-contract.js";
 import { stringify } from "yaml";
 import { z } from "zod";
+import { Effect } from "effect";
 import { randomBytes } from "node:crypto";
-import { CoreV1Api, CustomObjectsApi, KubeConfig } from "@kubernetes/client-node";
 //#region src/argo-submit.ts
 const scheduleIdSchema = z.string().regex(/^[a-z][a-z0-9-]*$/);
 const configMapSchema = z.object({
@@ -48,7 +49,10 @@ const commandScheduleOptionsSchema = z.object({
 	scheduleId: scheduleIdSchema.optional(),
 	task: z.string().min(1)
 }).strict();
-async function submitRunnerArgoWorkflow(rawOptions, dependencies = {}) {
+function submitRunnerArgoWorkflow(rawOptions, dependencies = {}) {
+	return Effect.runPromise(Effect.provide(Effect.suspend(() => submitRunnerArgoWorkflowEffect(rawOptions, dependencies)), KubernetesArgoServiceLive));
+}
+function submitRunnerArgoWorkflowEffect(rawOptions, dependencies) {
 	const { config, ...schemaOptions } = rawOptions;
 	const options = submitRunnerArgoWorkflowOptionsSchema.parse(schemaOptions);
 	const { payload, payloadJson } = normalizeRunnerPayloadForSubmit({
@@ -60,7 +64,7 @@ async function submitRunnerArgoWorkflow(rawOptions, dependencies = {}) {
 	const scheduleArtifactConfigMapName = `pipeline-schedule-${randomBytes(6).toString("hex")}`;
 	const taskDescriptorConfigMapName = `pipeline-task-descriptors-${randomBytes(6).toString("hex")}`;
 	if (payload.workflow.id !== compiled.workflowId) throw new Error(`Runner payload workflow '${payload.workflow.id}' does not match schedule workflow '${compiled.workflowId}'`);
-	const graph = compileSubmitArgoGraph(compiled);
+	const graphEffect = compileSubmitArgoGraph(compiled).pipe(Effect.mapError((error) => /* @__PURE__ */ new Error(`Schedule '${compiled.workflowId}' cannot be submitted: ${error.message}`)));
 	const labels = {
 		"pipeline.oisin.dev/project": payload.run.project,
 		"pipeline.oisin.dev/run-id": payload.run.id,
@@ -91,64 +95,72 @@ async function submitRunnerArgoWorkflow(rawOptions, dependencies = {}) {
 		serviceAccountName: options.serviceAccountName,
 		taskDescriptorConfigMapName
 	});
-	const { coreApi, workflowApi } = apiClients(options, dependencies);
-	await coreApi.createNamespacedConfigMap({
-		body: configMapSchema.parse({
-			apiVersion: "v1",
-			data: { "payload.json": payloadJson },
-			kind: "ConfigMap",
-			metadata: {
-				labels,
-				name: payloadConfigMapName,
-				namespace: options.namespace
-			}
-		}),
-		namespace: options.namespace
-	});
-	await coreApi.createNamespacedConfigMap({
-		body: configMapSchema.parse({
-			apiVersion: "v1",
-			data: Object.fromEntries(graph.tasks.map((task) => [`${task.taskName}.json`, `${JSON.stringify(buildRunnerTaskDescriptor(task.nodeId))}\n`])),
-			kind: "ConfigMap",
-			metadata: {
-				labels,
-				name: taskDescriptorConfigMapName,
-				namespace: options.namespace
-			}
-		}),
-		namespace: options.namespace
-	});
-	await coreApi.createNamespacedConfigMap({
-		body: configMapSchema.parse({
-			apiVersion: "v1",
-			data: { "schedule.yaml": options.scheduleYaml },
-			kind: "ConfigMap",
-			metadata: {
-				labels,
-				name: scheduleArtifactConfigMapName,
-				namespace: options.namespace
-			}
-		}),
-		namespace: options.namespace
-	});
-	const response = await workflowApi.createNamespacedCustomObject({
-		body: runnerArgoWorkflowManifestSchema.parse(workflow),
-		group: "argoproj.io",
-		namespace: options.namespace,
-		plural: "workflows",
-		version: "v1alpha1"
-	});
-	const created = z.object({ metadata: z.object({
-		name: z.string().min(1).optional(),
-		uid: z.string().min(1).optional()
-	}).passthrough() }).passthrough().parse(response);
-	return workflowSubmitResultSchema.parse({
-		namespace: options.namespace,
-		payloadConfigMapName,
-		scheduleConfigMapName: scheduleArtifactConfigMapName,
-		taskDescriptorConfigMapName,
-		workflowName: created.metadata.name ?? workflow.metadata.name,
-		workflowUid: created.metadata.uid
+	return Effect.gen(function* () {
+		const service = yield* KubernetesArgoService;
+		const graph = yield* graphEffect;
+		yield* service.createConfigMap({
+			body: configMapSchema.parse({
+				apiVersion: "v1",
+				data: { "payload.json": payloadJson },
+				kind: "ConfigMap",
+				metadata: {
+					labels,
+					name: payloadConfigMapName,
+					namespace: options.namespace
+				}
+			}),
+			dependencies,
+			namespace: options.namespace,
+			options
+		});
+		yield* service.createConfigMap({
+			body: configMapSchema.parse({
+				apiVersion: "v1",
+				data: Object.fromEntries(graph.tasks.map((task) => [`${task.taskName}.json`, `${JSON.stringify(buildRunnerTaskDescriptor(task.nodeId))}\n`])),
+				kind: "ConfigMap",
+				metadata: {
+					labels,
+					name: taskDescriptorConfigMapName,
+					namespace: options.namespace
+				}
+			}),
+			dependencies,
+			namespace: options.namespace,
+			options
+		});
+		yield* service.createConfigMap({
+			body: configMapSchema.parse({
+				apiVersion: "v1",
+				data: { "schedule.yaml": options.scheduleYaml },
+				kind: "ConfigMap",
+				metadata: {
+					labels,
+					name: scheduleArtifactConfigMapName,
+					namespace: options.namespace
+				}
+			}),
+			dependencies,
+			namespace: options.namespace,
+			options
+		});
+		const response = yield* service.createWorkflow({
+			body: runnerArgoWorkflowManifestSchema.parse(workflow),
+			dependencies,
+			namespace: options.namespace,
+			options
+		});
+		const created = z.object({ metadata: z.object({
+			name: z.string().min(1).optional(),
+			uid: z.string().min(1).optional()
+		}).passthrough() }).passthrough().parse(response);
+		return workflowSubmitResultSchema.parse({
+			namespace: options.namespace,
+			payloadConfigMapName,
+			scheduleConfigMapName: scheduleArtifactConfigMapName,
+			taskDescriptorConfigMapName,
+			workflowName: created.metadata.name ?? workflow.metadata.name,
+			workflowUid: created.metadata.uid
+		});
 	});
 }
 function buildCommandScheduleYaml(rawOptions) {
@@ -182,25 +194,13 @@ function normalizeRunnerPayloadForSubmit(input) {
 	};
 }
 function compileSubmitArgoGraph(compiled) {
-	try {
-		return compileArgoExecutionGraph(compiled.plan);
-	} catch (err) {
-		if (err instanceof ArgoGraphCompilerError) throw new Error(`Schedule '${compiled.workflowId}' cannot be submitted: ${err.message}`);
-		throw err;
-	}
-}
-function apiClients(options, dependencies) {
-	if (dependencies.coreApi && dependencies.workflowApi) return {
-		coreApi: dependencies.coreApi,
-		workflowApi: dependencies.workflowApi
-	};
-	const kubeConfig = dependencies.kubeConfig ?? new KubeConfig();
-	if (!dependencies.kubeConfig) if (options.kubeconfigPath) kubeConfig.loadFromFile(options.kubeconfigPath);
-	else kubeConfig.loadFromDefault();
-	return {
-		coreApi: dependencies.coreApi ?? kubeConfig.makeApiClient(CoreV1Api),
-		workflowApi: dependencies.workflowApi ?? kubeConfig.makeApiClient(CustomObjectsApi)
-	};
+	return Effect.try({
+		try: () => compileArgoExecutionGraph(compiled.plan),
+		catch: (error) => {
+			if (error instanceof ArgoGraphCompilerError) return error;
+			throw error;
+		}
+	});
 }
 //#endregion
 export { buildCommandScheduleYaml, submitRunnerArgoWorkflow };

package/dist/cluster-doctor.js

@@ -1,5 +1,6 @@
+import { KubernetesArgoService, KubernetesArgoServiceLive } from "./runtime/services/kubernetes-argo-service.js";
 import { loadMokaGlobalConfig } from "./moka-global-config.js";
-import { execa } from "execa";
+import { Effect } from "effect";
 //#region src/cluster-doctor.ts
 const DEFAULT_NAMESPACE = "momokaya-pipeline";
 const DEFAULT_RESOURCES = {
@@ -13,41 +14,46 @@ const DEFAULT_RESOURCES = {
 	serviceAccountName: "pipeline-runner"
 };
 const FORBIDDEN_RE = /forbidden/i;
-async function runClusterDoctor(options = {}) {
+function runClusterDoctor(options = {}) {
+	return Effect.runPromise(Effect.provide(Effect.suspend(() => runClusterDoctorEffect(options)), KubernetesArgoServiceLive));
+}
+function runClusterDoctorEffect(options = {}) {
 	const resources = clusterResources();
 	const namespace = options.namespace ?? DEFAULT_NAMESPACE;
 	const kubectlOptions = {
 		kubeContext: options.kubeContext,
 		kubeconfigPath: options.kubeconfigPath
 	};
-	const checks = await Promise.all([
-		checkKubectlNamespace(namespace, kubectlOptions),
-		...secretChecks(namespace, kubectlOptions, resources),
-		checkExternalSecret(namespace, resources.eventAuthExternalSecretName, resources.externalSecretRemoteRef, kubectlOptions),
-		checkClusterSecretStore("openbao", kubectlOptions),
-		checkServiceAccount(namespace, resources.serviceAccountName, kubectlOptions),
-		checkWorkflowSubmitPermission(namespace, {
-			resource: "workflows.argoproj.io",
-			verb: "create",
-			...kubectlOptions
-		}),
-		checkClusterResource("argo-workflow-crd", [
-			"get",
-			"crd",
-			"workflows.argoproj.io"
-		], kubectlOptions),
-		checkClusterResource("argo-workflow-controller", [
-			"get",
-			"pods",
-			"-A",
-			"-l",
-			"app=workflow-controller"
-		], kubectlOptions)
-	]);
-	return {
-		checks,
-		passed: checks.every((check) => check.passed)
-	};
+	return Effect.gen(function* () {
+		const checks = yield* Effect.all([
+			checkKubectlNamespace(namespace, kubectlOptions),
+			...secretChecks(namespace, kubectlOptions, resources),
+			checkExternalSecret(namespace, resources.eventAuthExternalSecretName, resources.externalSecretRemoteRef, kubectlOptions),
+			checkClusterSecretStore("openbao", kubectlOptions),
+			checkServiceAccount(namespace, resources.serviceAccountName, kubectlOptions),
+			checkWorkflowSubmitPermission(namespace, {
+				resource: "workflows.argoproj.io",
+				verb: "create",
+				...kubectlOptions
+			}),
+			checkClusterResource("argo-workflow-crd", [
+				"get",
+				"crd",
+				"workflows.argoproj.io"
+			], kubectlOptions),
+			checkClusterResource("argo-workflow-controller", [
+				"get",
+				"pods",
+				"-A",
+				"-l",
+				"app=workflow-controller"
+			], kubectlOptions)
+		], { concurrency: "unbounded" });
+		return {
+			checks,
+			passed: checks.every((check) => check.passed)
+		};
+	});
 }
 function defaultClusterDoctorNamespace() {
 	return DEFAULT_NAMESPACE;
@@ -89,9 +95,8 @@ function checkKubectlNamespace(namespace, kubectlOptions) {
 		namespace
 	], `Namespace ${namespace} missing or inaccessible.`, kubectlOptions);
 }
-async function checkNamespacedResource(name, args, missingDetail, kubectlOptions) {
-	const result = await kubectl(args, kubectlOptions);
-	return result.ok ? {
+function checkNamespacedResource(name, args, missingDetail, kubectlOptions) {
+	return kubectl(args, kubectlOptions).pipe(Effect.map((result) => result.ok ? {
 		detail: "present",
 		name,
 		passed: true
@@ -99,10 +104,10 @@ async function checkNamespacedResource(name, args, missingDetail, kubectlOptions
 		detail: inaccessibleOrMissingDetail(name, missingDetail, result),
 		name,
 		passed: false
-	};
+	}));
 }
-async function checkExternalSecret(namespace, name, remoteRef, kubectlOptions) {
-	const result = await kubectl([
+function checkExternalSecret(namespace, name, remoteRef, kubectlOptions) {
+	return kubectl([
 		"get",
 		"externalsecret",
 		name,
@@ -110,34 +115,36 @@ async function checkExternalSecret(namespace, name, remoteRef, kubectlOptions) {
 		namespace,
 		"-o",
 		"json"
-	], kubectlOptions);
-	if (!result.ok) {
-		const missingDetail = `ExternalSecret ${name} missing in ${namespace}; expected it to sync ${remoteRef}.`;
-		return {
-			detail: inaccessibleOrMissingDetail(`externalsecret/${name}`, missingDetail, result),
-			name: `externalsecret/${name}`,
-			passed: false
-		};
-	}
-	return readyConditionCheck(`externalsecret/${name}`, result.stdout);
-}
-async function checkClusterSecretStore(name, kubectlOptions) {
-	const result = await kubectl([
+	], kubectlOptions).pipe(Effect.map((result) => {
+		if (!result.ok) {
+			const missingDetail = `ExternalSecret ${name} missing in ${namespace}; expected it to sync ${remoteRef}.`;
+			return {
+				detail: inaccessibleOrMissingDetail(`externalsecret/${name}`, missingDetail, result),
+				name: `externalsecret/${name}`,
+				passed: false
+			};
+		}
+		return readyConditionCheck(`externalsecret/${name}`, result.stdout);
+	}));
+}
+function checkClusterSecretStore(name, kubectlOptions) {
+	return kubectl([
 		"get",
 		"clustersecretstore",
 		name,
 		"-o",
 		"json"
-	], kubectlOptions);
-	if (!result.ok) {
-		const missingDetail = `ClusterSecretStore/${name} missing or inaccessible; OpenBao/ESO readiness is an external prerequisite.`;
-		return {
-			detail: inaccessibleOrMissingDetail(`clustersecretstore/${name}`, missingDetail, result),
-			name: `clustersecretstore/${name}`,
-			passed: false
-		};
-	}
-	return readyConditionCheck(`clustersecretstore/${name}`, result.stdout);
+	], kubectlOptions).pipe(Effect.map((result) => {
+		if (!result.ok) {
+			const missingDetail = `ClusterSecretStore/${name} missing or inaccessible; OpenBao/ESO readiness is an external prerequisite.`;
+			return {
+				detail: inaccessibleOrMissingDetail(`clustersecretstore/${name}`, missingDetail, result),
+				name: `clustersecretstore/${name}`,
+				passed: false
+			};
+		}
+		return readyConditionCheck(`clustersecretstore/${name}`, result.stdout);
+	}));
 }
 function checkServiceAccount(namespace, name, kubectlOptions) {
 	return checkNamespacedResource(`serviceaccount/${name}`, [
@@ -148,15 +155,15 @@ function checkServiceAccount(namespace, name, kubectlOptions) {
 		namespace
 	], `ServiceAccount ${name} missing in ${namespace}; runner pods must use this account for workflow execution.`, kubectlOptions);
 }
-async function checkWorkflowSubmitPermission(namespace, options) {
-	return (await kubectl([
+function checkWorkflowSubmitPermission(namespace, options) {
+	return kubectl([
 		"auth",
 		"can-i",
 		options.verb,
 		options.resource,
 		"-n",
 		namespace
-	], options)).stdout.trim() === "yes" ? {
+	], options).pipe(Effect.map((result) => result.stdout.trim() === "yes" ? {
 		detail: `current kube identity can ${options.verb} ${options.resource}`,
 		name: "rbac/workflow-create",
 		passed: true
@@ -164,11 +171,10 @@ async function checkWorkflowSubmitPermission(namespace, options) {
 		detail: `current kube identity cannot ${options.verb} ${options.resource}; check submitter RBAC for Workflow creation.`,
 		name: "rbac/workflow-create",
 		passed: false
-	};
+	}));
 }
-async function checkClusterResource(name, args, kubectlOptions) {
-	const result = await kubectl(args, kubectlOptions);
-	return result.ok ? {
+function checkClusterResource(name, args, kubectlOptions) {
+	return kubectl(args, kubectlOptions).pipe(Effect.map((result) => result.ok ? {
 		detail: "present",
 		name,
 		passed: true
@@ -176,46 +182,28 @@ async function checkClusterResource(name, args, kubectlOptions) {
 		detail: isForbidden(result) ? inaccessibleDetail(name, result) : result.stderr || "missing or inaccessible",
 		name,
 		passed: false
-	};
+	}));
+}
+function findReadyCondition(source) {
+	return parseJson(source).status?.conditions?.find((condition) => condition.type === "Ready");
+}
+function readyDetail(ready, passed) {
+	const fallback = passed ? "Ready=True" : "Ready condition is missing or not True";
+	return ready?.message || fallback;
 }
 function readyConditionCheck(name, source) {
-	const ready = parseJson(source).status?.conditions?.find((condition) => condition.type === "Ready");
-	return ready?.status === "True" ? {
-		detail: ready.message || "Ready=True",
-		name,
-		passed: true
-	} : {
-		detail: ready?.message || "Ready condition is missing or not True",
+	const ready = findReadyCondition(source);
+	const passed = ready?.status === "True";
+	return {
+		detail: readyDetail(ready, passed),
 		name,
-		passed: false
+		passed
 	};
 }
-async function kubectl(args, options) {
-	try {
-		const result = await execa("kubectl", kubectlArgs(args, options.kubeContext), {
-			env: options.kubeconfigPath ? { KUBECONFIG: options.kubeconfigPath } : void 0,
-			stdin: "ignore"
-		});
-		return {
-			ok: true,
-			stderr: result.stderr,
-			stdout: result.stdout
-		};
-	} catch (err) {
-		const error = err;
-		return {
-			ok: false,
-			stderr: (error.stderr || error.shortMessage || "kubectl failed").trim(),
-			stdout: (error.stdout || "").trim()
-		};
-	}
-}
-function kubectlArgs(args, kubeContext) {
-	return kubeContext ? [
-		"--context",
-		kubeContext,
-		...args
-	] : args;
+function kubectl(args, options) {
+	return Effect.gen(function* () {
+		return yield* (yield* KubernetesArgoService).kubectl(args, options);
+	});
 }
 function inaccessibleOrMissingDetail(name, missingDetail, result) {
 	return isForbidden(result) ? inaccessibleDetail(name, result) : missingDetail;

package/dist/config/defaults.js

@@ -1,7 +1,6 @@
-import { PipelineConfigError, configIssuesFromZodError, validationError } from "./schemas.js";
-import { parseDocument } from "yaml";
+import { ConfigIoService, parseConfigYamlAs, runConfigIoSync } from "../runtime/services/config-io-service.js";
 import { z } from "zod";
-import { readFileSync } from "node:fs";
+import { Effect } from "effect";
 //#region src/config/defaults.ts
 const PIPELINE_CONFIG_PATH = ".pipeline/pipeline.yaml";
 const RUNNERS_CONFIG_PATH = ".pipeline/runners.yaml";
@@ -9,7 +8,9 @@ const PROFILES_CONFIG_PATH = ".pipeline/profiles.yaml";
 const OPENCODE_ECOSYSTEM_MANIFEST_PATH = "defaults/opencode-ecosystem.yaml";
 const DEFAULT_PACKAGE_DEFAULTS_ROOT = new URL("../../defaults/", import.meta.url);
 function loadDefaultYaml(filename) {
-	return readFileSync(new URL(filename, DEFAULT_PACKAGE_DEFAULTS_ROOT), "utf8");
+	return runConfigIoSync(Effect.gen(function* () {
+		return yield* (yield* ConfigIoService).readText(new URL(filename, DEFAULT_PACKAGE_DEFAULTS_ROOT));
+	}));
 }
 const PACKAGE_DEFAULT_RUNNERS_YAML = loadDefaultYaml("runners.yaml");
 const PACKAGE_DEFAULT_PROFILES_YAML = loadDefaultYaml("profiles.yaml");
@@ -111,24 +112,13 @@ const openCodeEcosystemManifestSchema = z.object({
 	version: z.literal(1)
 }).strict();
 function parseOpenCodeEcosystemManifest(source, sourcePath = OPENCODE_ECOSYSTEM_MANIFEST_PATH) {
-	return parseYamlAs(source, sourcePath, openCodeEcosystemManifestSchema);
+	return runConfigIoSync(parseConfigYamlAs(source, sourcePath, openCodeEcosystemManifestSchema));
 }
 function loadDefaultOpenCodeEcosystemManifest() {
-	return parseOpenCodeEcosystemManifest(readFileSync(DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST_URL, "utf8"));
+	return runConfigIoSync(Effect.gen(function* () {
+		return yield* parseConfigYamlAs(yield* (yield* ConfigIoService).readText(DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST_URL), OPENCODE_ECOSYSTEM_MANIFEST_PATH, openCodeEcosystemManifestSchema);
+	}));
 }
 const DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST = loadDefaultOpenCodeEcosystemManifest();
-function parseYamlAs(source, sourcePath, schema) {
-	const document = parseDocument(source, {
-		prettyErrors: false,
-		uniqueKeys: true
-	});
-	if (document.errors.length > 0) throw new PipelineConfigError("PIPELINE_CONFIG_PARSE_ERROR", `Failed to parse ${sourcePath}`, document.errors.map((err) => ({
-		message: err.message,
-		path: sourcePath
-	})));
-	const parsed = schema.safeParse(document.toJS());
-	if (!parsed.success) throw validationError(configIssuesFromZodError(parsed.error));
-	return parsed.data;
-}
 //#endregion
 export { DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST, OPENCODE_ECOSYSTEM_MANIFEST_PATH, PACKAGE_DEFAULT_PIPELINE_YAML, PACKAGE_DEFAULT_PROFILES_YAML, PACKAGE_DEFAULT_RUNNERS_YAML, PIPELINE_CONFIG_PATH, PROFILES_CONFIG_PATH, RUNNERS_CONFIG_PATH, parseOpenCodeEcosystemManifest };

package/dist/config/load.js

@@ -1,13 +1,14 @@
-import { PipelineConfigError, configIssuesFromZodError, pipelineFileSchema, profilesFileSchema, runnersFileSchema, validationError } from "./schemas.js";
+import { pipelineFileSchema, profilesFileSchema, runnersFileSchema } from "./schemas.js";
+import { parseConfigYamlAs, runConfigIoSync } from "../runtime/services/config-io-service.js";
 import { PACKAGE_DEFAULT_PIPELINE_YAML, PACKAGE_DEFAULT_PROFILES_YAML, PACKAGE_DEFAULT_RUNNERS_YAML, PIPELINE_CONFIG_PATH, PROFILES_CONFIG_PATH, RUNNERS_CONFIG_PATH } from "./defaults.js";
 import { validatePipelineConfig } from "./validate.js";
-import { parseDocument } from "yaml";
+import { Effect } from "effect";
 //#region src/config/load.ts
 function loadPipelineConfig(projectRoot, options = {}) {
 	return loadPackagePipelineConfig(projectRoot, options);
 }
 function loadPackagePipelineConfig(projectRoot, options = {}) {
-	return parsePipelineConfigParts({
+	return runConfigIoSync(parsePipelineConfigPartsEffect({
 		pipeline: PACKAGE_DEFAULT_PIPELINE_YAML,
 		profiles: PACKAGE_DEFAULT_PROFILES_YAML,
 		runners: PACKAGE_DEFAULT_RUNNERS_YAML
@@ -15,7 +16,7 @@ function loadPackagePipelineConfig(projectRoot, options = {}) {
 		pipeline: "@oisincoveney/pipeline/defaults/pipeline.yaml",
 		profiles: "@oisincoveney/pipeline/defaults/profiles.yaml",
 		runners: "@oisincoveney/pipeline/defaults/runners.yaml"
-	}, options);
+	}, options));
 }
 function parsePipelineConfigYaml(source, sourcePath = PIPELINE_CONFIG_PATH, projectRoot) {
 	return parsePipelineConfigParts({
@@ -48,43 +49,35 @@ function parsePipelineConfigParts(sources, projectRoot, sourcePaths = {
 	profiles: PROFILES_CONFIG_PATH,
 	runners: RUNNERS_CONFIG_PATH
 }, options = {}) {
-	const runners = parseYamlAs(sources.runners, sourcePaths.runners, runnersFileSchema);
-	const profiles = parseYamlAs(sources.profiles, sourcePaths.profiles, profilesFileSchema);
-	const pipeline = parseYamlAs(sources.pipeline, sourcePaths.pipeline, pipelineFileSchema);
-	return validatePipelineConfig({
-		default_workflow: pipeline.default_workflow,
-		...durabilityField(pipeline.durability),
-		...pipe83Fields(pipeline),
-		entrypoints: pipeline.entrypoints,
-		hooks: pipeline.hooks,
-		...profiles.mcp_gateway ? { mcp_gateway: profiles.mcp_gateway } : {},
-		mcp_servers: profiles.mcp_servers,
-		...pipeline.orchestrator ? { orchestrator: pipeline.orchestrator } : {},
-		profiles: profiles.profiles,
-		runner_command: pipeline.runner_command,
-		rules: profiles.rules,
-		runners: runners.runners,
-		scheduler: pipeline.scheduler,
-		schedules: pipeline.schedules,
-		skills: profiles.skills,
-		...pipeline.task_context ? { task_context: pipeline.task_context } : {},
-		token_budget: pipeline.token_budget,
-		version: 1,
-		workflows: pipeline.workflows
-	}, projectRoot, options);
+	return runConfigIoSync(parsePipelineConfigPartsEffect(sources, projectRoot, sourcePaths, options));
 }
-function parseYamlAs(source, sourcePath, schema) {
-	const document = parseDocument(source, {
-		prettyErrors: false,
-		uniqueKeys: true
+function parsePipelineConfigPartsEffect(sources, projectRoot, sourcePaths, options) {
+	return Effect.gen(function* () {
+		const runners = yield* parseConfigYamlAs(sources.runners, sourcePaths.runners, runnersFileSchema);
+		const profiles = yield* parseConfigYamlAs(sources.profiles, sourcePaths.profiles, profilesFileSchema);
+		const pipeline = yield* parseConfigYamlAs(sources.pipeline, sourcePaths.pipeline, pipelineFileSchema);
+		return validatePipelineConfig({
+			default_workflow: pipeline.default_workflow,
+			...durabilityField(pipeline.durability),
+			...pipe83Fields(pipeline),
+			entrypoints: pipeline.entrypoints,
+			hooks: pipeline.hooks,
+			...profiles.mcp_gateway ? { mcp_gateway: profiles.mcp_gateway } : {},
+			mcp_servers: profiles.mcp_servers,
+			...pipeline.orchestrator ? { orchestrator: pipeline.orchestrator } : {},
+			profiles: profiles.profiles,
+			runner_command: pipeline.runner_command,
+			rules: profiles.rules,
+			runners: runners.runners,
+			scheduler: pipeline.scheduler,
+			schedules: pipeline.schedules,
+			skills: profiles.skills,
+			...pipeline.task_context ? { task_context: pipeline.task_context } : {},
+			token_budget: pipeline.token_budget,
+			version: 1,
+			workflows: pipeline.workflows
+		}, projectRoot, options);
 	});
-	if (document.errors.length > 0) throw new PipelineConfigError("PIPELINE_CONFIG_PARSE_ERROR", `Failed to parse ${sourcePath}`, document.errors.map((err) => ({
-		message: err.message,
-		path: sourcePath
-	})));
-	const parsed = schema.safeParse(document.toJS());
-	if (!parsed.success) throw validationError(configIssuesFromZodError(parsed.error));
-	return parsed.data;
 }
 //#endregion
 export { loadPackagePipelineConfig, loadPipelineConfig, parsePipelineConfigParts, parsePipelineConfigYaml };