@oisincoveney/pipeline 2.8.0 → 2.8.2

package/dist/runtime/opencode-session-executor.js

@@ -1,4 +1,6 @@
+import { OpencodeSdkService, OpencodeSdkServiceLive } from "./services/opencode-sdk-service.js";
 import { opencodeAgentName } from "./opencode-agent-name.js";
+import { Effect } from "effect";
 //#region src/runtime/opencode-session-executor.ts
 function createOpencodeSessionRegistry() {
 	return { sessions: /* @__PURE__ */ new Map() };
@@ -18,45 +20,69 @@ const EXIT_INFRA = 70;
 */
 function createOpencodeExecutor(deps) {
 	return async function execute(plan, options = {}) {
-		if (plan.type !== "opencode") throw new Error(`opencode executor cannot drive runner type '${plan.type}'`);
-		try {
-			return successResult(plan, await driveSession(deps, plan, options));
-		} catch (error) {
-			return failureResult(plan, error);
-		}
+		return await Effect.runPromise(Effect.provide(executeOpencodeEffect(deps, plan, options), OpencodeSdkServiceLive));
 	};
 }
+function executeOpencodeEffect(deps, plan, options) {
+	return Effect.gen(function* () {
+		yield* validateOpencodePlan(plan);
+		return yield* executeOpencodeSession(deps, plan, options);
+	});
+}
+function executeOpencodeSession(deps, plan, options) {
+	return Effect.gen(function* () {
+		return successResult(plan, yield* driveSession(deps, plan, options));
+	}).pipe(Effect.catchAll((error) => Effect.succeed(failureResult(plan, error))));
+}
+function validateOpencodePlan(plan) {
+	if (plan.type === "opencode") return Effect.void;
+	return Effect.fail(/* @__PURE__ */ new Error(`opencode executor cannot drive runner type '${plan.type}'`));
+}
 function sessionDirectory(deps, plan) {
 	return plan.cwd ?? deps.directory;
 }
-async function driveSession(deps, plan, options) {
-	const sessionId = await resolveSessionId(deps, plan);
-	deps.onSession?.(plan.nodeId, sessionId);
-	const stream = await streamEventsToOutput(deps, sessionId, plan, options);
-	try {
-		const data = unwrap(await deps.client.session.prompt({
-			body: promptBody(plan),
-			path: { id: sessionId },
-			query: { directory: sessionDirectory(deps, plan) }
-		}));
+function driveSession(deps, plan, options) {
+	return Effect.gen(function* () {
+		const sessionId = yield* resolveSessionId(deps, plan);
+		recordSession(deps, plan.nodeId, sessionId);
+		const stream = yield* streamEventsToOutput(deps, sessionId, plan, options);
+		return yield* promptSessionResult(deps, plan, sessionId).pipe(Effect.ensuring(stopStream(stream)));
+	});
+}
+function promptSessionResult(deps, plan, sessionId) {
+	return Effect.gen(function* () {
+		const data = unwrap(yield* (yield* OpencodeSdkService).promptSession(deps.client, promptRequest(deps, plan, sessionId)));
 		return {
 			...data.info ? { assistant: data.info } : {},
 			parts: data.parts ?? [],
 			sessionId
 		};
-	} finally {
-		await stream.stop();
-	}
+	});
+}
+function promptRequest(deps, plan, sessionId) {
+	return {
+		body: promptBody(plan),
+		path: { id: sessionId },
+		query: { directory: sessionDirectory(deps, plan) }
+	};
+}
+function stopStream(stream) {
+	return Effect.tryPromise(() => stream.stop()).pipe(Effect.asVoid, Effect.catchAll(() => Effect.void));
 }
-async function resolveSessionId(deps, plan) {
+function recordSession(deps, nodeId, sessionId) {
+	deps.onSession?.(nodeId, sessionId);
+}
+function resolveSessionId(deps, plan) {
 	const existing = deps.registry.sessions.get(plan.nodeId);
-	if (existing) return existing;
-	const session = unwrap(await deps.client.session.create({
-		body: { title: `moka:${plan.nodeId}` },
-		query: { directory: plan.cwd ?? deps.directory }
-	}));
-	deps.registry.sessions.set(plan.nodeId, session.id);
-	return session.id;
+	if (existing) return Effect.succeed(existing);
+	return Effect.gen(function* () {
+		const session = unwrap(yield* (yield* OpencodeSdkService).createSession(deps.client, {
+			body: { title: `moka:${plan.nodeId}` },
+			query: { directory: plan.cwd ?? deps.directory }
+		}));
+		deps.registry.sessions.set(plan.nodeId, session.id);
+		return session.id;
+	});
 }
 function promptBody(plan) {
 	const prompt = promptText(plan);
@@ -95,24 +121,55 @@ function parseModel(model) {
 		providerID: model.slice(0, slash)
 	};
 }
-async function streamEventsToOutput(deps, sessionId, plan, options) {
-	if (!options.onOutput) return { stop: () => Promise.resolve() };
-	const iterator = (await deps.client.event.subscribe()).stream;
-	const pump = (async () => {
-		try {
-			for await (const event of iterator) forwardEvent(event, sessionId, plan, options);
-		} catch (error) {
-			options.onOutput?.({
-				chunk: `opencode event stream dropped: ${errorMessage(error)}\n`,
-				nodeId: plan.nodeId,
-				stream: "stderr"
-			});
+function streamEventsToOutput(deps, sessionId, plan, options) {
+	if (!options.onOutput) return Effect.succeed({ stop: () => Promise.resolve() });
+	return Effect.gen(function* () {
+		const iterator = (yield* (yield* OpencodeSdkService).subscribeEvents(deps.client)).stream;
+		const pump = Effect.runPromise(pumpEvents(iterator, sessionId, plan, options));
+		return { stop: () => stopIterator(iterator, pump) };
+	});
+}
+function pumpEvents(iterator, sessionId, plan, options) {
+	return Effect.gen(function* () {
+		let done = false;
+		while (!done) {
+			const next = yield* readNextEvent(iterator);
+			done = next.done === true;
+			if (!done) forwardEvent(next.value, sessionId, plan, options);
 		}
-	})();
-	return { stop: async () => {
-		await iterator.return?.(void 0);
-		await pump;
-	} };
+	}).pipe(Effect.catchAll((error) => reportStreamDrop(error, plan, options)));
+}
+function readNextEvent(iterator) {
+	return Effect.tryPromise({
+		catch: (error) => error,
+		try: () => iterator.next()
+	});
+}
+function reportStreamDrop(error, plan, options) {
+	return Effect.sync(() => {
+		options.onOutput?.({
+			chunk: `opencode event stream dropped: ${errorMessage(error)}\n`,
+			nodeId: plan.nodeId,
+			stream: "stderr"
+		});
+	});
+}
+function stopIterator(iterator, pump) {
+	return Effect.runPromise(stopIteratorEffect(iterator, pump));
+}
+function stopIteratorEffect(iterator, pump) {
+	return Effect.gen(function* () {
+		yield* requestIteratorReturn(iterator);
+		yield* Effect.tryPromise(() => pump).pipe(Effect.catchAll(() => Effect.void));
+	});
+}
+function requestIteratorReturn(iterator) {
+	const returnIterator = iterator.return;
+	if (!returnIterator) return Effect.void;
+	return Effect.tryPromise({
+		catch: (error) => error,
+		try: () => returnIterator.call(iterator, void 0)
+	}).pipe(Effect.asVoid, Effect.catchAll(() => Effect.void));
 }
 function forwardEvent(event, sessionId, plan, options) {
 	const forwarded = eventChunk(event, sessionId);

package/dist/runtime/parallel-node/parallel-node.js

@@ -1,5 +1,6 @@
 import { childReporter } from "../events/events.js";
 import "../events/index.js";
+import { configUsesOpencode, leaseOpencodeRuntime } from "../opencode-runtime.js";
 import { WorktreeService, WorktreeServiceLive } from "../services/worktree-service.js";
 import { Effect } from "effect";
 //#region src/runtime/parallel-node/parallel-node.ts
@@ -76,15 +77,33 @@ function gcStaleWorktrees(context) {
 * interruption); release retains dirty/unpushed work for downstream selection.
 */
 function runChildInWorktree(child, context, runtime) {
-	if (!context.config.parallel_worktrees?.enabled) return Effect.promise(() => runtime.executeNode(child, context));
+	if (!context.config.parallel_worktrees?.enabled) return executeChild(child, context, runtime);
 	return Effect.gen(function* () {
 		const worktree = yield* WorktreeService;
-		return yield* Effect.acquireUseRelease(worktree.createChild(childLeaseOptions(child, context)), (lease) => Effect.promise(() => runtime.executeNode(child, {
-			...context,
-			worktreePath: lease.path
-		})), (lease) => Effect.sync(() => lease.release()));
+		return yield* Effect.acquireUseRelease(worktree.createChild(childLeaseOptions(child, context)), (lease) => runChildWithWorktreeLease(child, context, runtime, lease.path), (lease) => Effect.sync(() => lease.release()));
 	});
 }
+function executeChild(child, context, runtime) {
+	return Effect.tryPromise(() => runtime.executeNode(child, context)).pipe(Effect.orDie);
+}
+function runChildWithWorktreeLease(child, context, runtime, worktreePath) {
+	const childContext = {
+		...context,
+		worktreePath
+	};
+	if (!configUsesOpencode(context.config)) return executeChild(child, childContext, runtime);
+	return Effect.acquireUseRelease(leaseChildOpencodeRuntime(context, worktreePath), (childRuntime) => executeChild(child, {
+		...childContext,
+		executor: childRuntime.executor
+	}, runtime), (childRuntime) => Effect.tryPromise(() => childRuntime.release()).pipe(Effect.orDie));
+}
+function leaseChildOpencodeRuntime(context, worktreePath) {
+	return Effect.tryPromise(() => leaseOpencodeRuntime({
+		config: context.config,
+		...context.signal ? { signal: context.signal } : {},
+		worktreePath
+	})).pipe(Effect.orDie);
+}
 function childLeaseOptions(child, context) {
 	return {
 		childNodeId: child.id,

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

@@ -2,7 +2,8 @@ import { createRunnerLaunchPlan } from "../../runner.js";
 import { normalizeRunnerOutput } from "../../runner-output.js";
 import { parseJsonObject } from "../json-validation/json-validation.js";
 import "../json-validation/index.js";
-import { promoteWorktreeChanges } from "../parallel-worktrees/parallel-worktrees.js";
+import { SelectCandidateService, SelectCandidateServiceLive } from "../services/select-candidate-service.js";
+import { Effect } from "effect";
 //#region src/runtime/select-candidate/select-candidate.ts
 const SCORE_RE = /-?\d+(?:\.\d+)?/;
 function selectBestCandidate(candidates) {
@@ -11,19 +12,25 @@ function selectBestCandidate(candidates) {
 	return passing.reduce((best, candidate) => (candidate.judgeScore ?? 0) > (best.judgeScore ?? 0) ? candidate : best);
 }
 async function executeSelectCandidateBuiltin(context, node) {
-	const candidates = await scoreCandidates(context, readCandidates(context, node?.needs.at(0) ?? null));
-	const selected = selectBestCandidate(candidates);
-	if (!selected) return {
-		evidence: [`select-candidate: no passing candidate among ${candidates.length}`, ...candidates.map((candidate) => `- ${candidate.nodeId}: FAIL`)],
-		exitCode: 1,
-		output: ""
-	};
-	const promoted = promoteWinner(context, node, selected.nodeId);
-	return {
-		evidence: selectionEvidence(selected, candidates.length, promoted),
-		exitCode: 0,
-		output: selected.output
-	};
+	const program = executeSelectCandidateBuiltinProgram(context, node);
+	return await Effect.runPromise(Effect.provide(program, SelectCandidateServiceLive));
+}
+function executeSelectCandidateBuiltinProgram(context, node) {
+	return Effect.gen(function* () {
+		const candidates = yield* scoreCandidates(context, readCandidates(context, firstNeed(node)));
+		const selected = selectBestCandidate(candidates);
+		if (!selected) return {
+			evidence: [`select-candidate: no passing candidate among ${candidates.length}`, ...candidates.map((candidate) => `- ${candidate.nodeId}: FAIL`)],
+			exitCode: 1,
+			output: ""
+		};
+		const promoted = yield* promoteWinner(context, node, selected.nodeId);
+		return {
+			evidence: selectionEvidence(selected, candidates.length, promoted),
+			exitCode: 0,
+			output: selected.output
+		};
+	});
 }
 function selectionEvidence(selected, candidateCount, promoted) {
 	const lines = [`select-candidate: selected '${selected.nodeId}' (judge=${selected.judgeScore ?? "n/a"}) from ${candidateCount} candidates`];
@@ -31,24 +38,33 @@ function selectionEvidence(selected, candidateCount, promoted) {
 	return lines;
 }
 function promoteWinner(context, node, winnerNodeId) {
-	const parentNodeId = node?.needs.at(0);
-	if (!(context.config.parallel_worktrees?.enabled && parentNodeId)) return [];
-	return promoteWorktreeChanges(context.worktreePath, context.runId, parentNodeId, winnerNodeId);
+	const parentNodeId = firstNeed(node);
+	if (!shouldPromoteWinner(context, parentNodeId)) return Effect.succeed([]);
+	return SelectCandidateService.pipe(Effect.flatMap((service) => service.promoteWinner(context.worktreePath, context.runId, parentNodeId, winnerNodeId)));
 }
-async function scoreCandidates(context, candidates) {
+function shouldPromoteWinner(context, parentNodeId) {
+	const parallelWorktrees = context.config.parallel_worktrees;
+	return Boolean(parallelWorktrees?.enabled) && parentNodeId !== null;
+}
+function firstNeed(node) {
+	return node?.needs.at(0) ?? null;
+}
+function scoreCandidates(context, candidates) {
 	const model = context.config.best_of_n?.judge_model;
 	const runner = Object.keys(context.config.runners).at(0);
-	if (!(model && runner)) return candidates;
-	return await Promise.all(candidates.map((candidate) => scoreCandidate(context, candidate, runner, model)));
-}
-async function scoreCandidate(context, candidate, runner, model) {
-	const plan = judgePlan(context, candidate, runner, model);
-	context.agentInvocations.push(plan);
-	const judgeScore = parseScore(normalizeRunnerOutput(plan, (await context.executor(plan, { signal: context.signal })).stdout).output);
-	return judgeScore === null ? candidate : {
-		...candidate,
-		judgeScore
-	};
+	if (!(model && runner)) return Effect.succeed(candidates);
+	return Effect.forEach(candidates, (candidate) => scoreCandidate(context, candidate, runner, model), { concurrency: "unbounded" });
+}
+function scoreCandidate(context, candidate, runner, model) {
+	return Effect.gen(function* () {
+		const plan = judgePlan(context, candidate, runner, model);
+		context.agentInvocations.push(plan);
+		const judgeScore = parseScore(normalizeRunnerOutput(plan, (yield* (yield* SelectCandidateService).executeRunner(context.executor, plan, { signal: context.signal })).stdout).output);
+		return judgeScore === null ? candidate : {
+			...candidate,
+			judgeScore
+		};
+	});
 }
 function judgePlan(context, candidate, runner, model) {
 	const profileId = `select-candidate:judge:${candidate.nodeId}`;

package/dist/runtime/services/agent-node-runtime-service.js

@@ -0,0 +1,15 @@
+import { buildRepoMapContext } from "../../context/repo-map.js";
+import { Context, Effect, Layer } from "effect";
+import { readFileSync } from "node:fs";
+//#region src/runtime/services/agent-node-runtime-service.ts
+var AgentNodeRuntimeService = class extends Context.Tag("AgentNodeRuntimeService")() {};
+const AgentNodeRuntimeServiceLive = Layer.succeed(AgentNodeRuntimeService, {
+	buildRepoMap: buildRepoMapContext,
+	executeRunner: (executor, plan, options) => Effect.tryPromise({
+		catch: (error) => error,
+		try: () => Promise.resolve(executor(plan, options))
+	}),
+	readText: (path) => Effect.sync(() => readFileSync(path, "utf8"))
+});
+//#endregion
+export { AgentNodeRuntimeService, AgentNodeRuntimeServiceLive };

package/dist/runtime/services/command-executor-service.js

@@ -0,0 +1,8 @@
+import { executeCommand } from "../command-executor/command-executor.js";
+import "../command-executor/index.js";
+import { Context, Effect, Layer } from "effect";
+//#region src/runtime/services/command-executor-service.ts
+var CommandExecutor = class extends Context.Tag("CommandExecutor")() {};
+const CommandExecutorLive = Layer.succeed(CommandExecutor, { execute: (command, context, options) => Effect.tryPromise(() => executeCommand(command, context, options)) });
+//#endregion
+export { CommandExecutor, CommandExecutorLive };

package/dist/runtime/services/config-io-service.js

@@ -0,0 +1,42 @@
+import { PipelineConfigError, configIssuesFromZodError, validationError } from "../../config/schemas.js";
+import { parseDocument } from "yaml";
+import { Cause, Context, Effect, Layer, Option } from "effect";
+import { existsSync, readFileSync } from "node:fs";
+//#region src/runtime/services/config-io-service.ts
+function parseYamlSource(source, sourcePath) {
+	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
+	})));
+	return document.toJS();
+}
+var ConfigIoService = class extends Context.Tag("ConfigIoService")() {};
+const ConfigIoServiceLive = Layer.succeed(ConfigIoService, {
+	parseYaml: (source, sourcePath) => Effect.try({
+		try: () => parseYamlSource(source, sourcePath),
+		catch: (error) => error
+	}),
+	readOptionalText: (path) => Effect.sync(() => existsSync(path) ? readFileSync(path, "utf8") : null),
+	readText: (path) => Effect.sync(() => readFileSync(path, "utf8"))
+});
+function parseConfigYamlAs(source, sourcePath, schema) {
+	return Effect.gen(function* () {
+		const yaml = yield* (yield* ConfigIoService).parseYaml(source, sourcePath);
+		const parsed = schema.safeParse(yaml);
+		if (!parsed.success) return yield* Effect.fail(validationError(configIssuesFromZodError(parsed.error)));
+		return parsed.data;
+	});
+}
+function runConfigIoSync(program) {
+	const exit = Effect.runSyncExit(Effect.provide(program, ConfigIoServiceLive));
+	if (exit._tag === "Success") return exit.value;
+	const failure = Cause.failureOption(exit.cause);
+	if (Option.isSome(failure)) throw failure.value;
+	throw Cause.squash(exit.cause);
+}
+//#endregion
+export { ConfigIoService, parseConfigYamlAs, runConfigIoSync };

package/dist/runtime/services/drain-merge-git-service.js

@@ -0,0 +1,10 @@
+import { Context, Effect, Layer } from "effect";
+import simpleGit$1 from "simple-git";
+//#region src/runtime/services/drain-merge-git-service.ts
+var DrainMergeGitService = class extends Context.Tag("DrainMergeGitService")() {};
+const DrainMergeGitServiceLive = Layer.succeed(DrainMergeGitService, { create: (baseDir) => Effect.sync(() => {
+	const git = simpleGit$1({ baseDir });
+	return { raw: (args) => Effect.tryPromise(() => git.raw(args)) };
+}) });
+//#endregion
+export { DrainMergeGitService, DrainMergeGitServiceLive };

package/dist/runtime/services/git-porcelain-service.js

@@ -0,0 +1,38 @@
+import { Context, Effect, Layer } from "effect";
+import { execFile, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
+//#region src/runtime/services/git-porcelain-service.ts
+const execGit = promisify(execFile);
+var GitPorcelainService = class extends Context.Tag("GitPorcelainService")() {};
+const GitPorcelainServiceLive = Layer.succeed(GitPorcelainService, {
+	run: (cwd, args, env) => Effect.tryPromise({
+		try: async () => {
+			const { stdout } = await execGit("git", args, {
+				cwd,
+				encoding: "utf8",
+				env
+			});
+			return stdout;
+		},
+		catch: (error) => error
+	}),
+	statusPorcelain: (cwd) => Effect.try({
+		try: () => execFileSync("git", [
+			"status",
+			"--porcelain=v1",
+			"--untracked-files=all",
+			"-z"
+		], {
+			cwd,
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}),
+		catch: (error) => error
+	})
+});
+//#endregion
+export { GitPorcelainService, GitPorcelainServiceLive };

package/dist/runtime/services/kubernetes-argo-service.d.ts

@@ -0,0 +1,13 @@
+import { Context, Effect, Layer } from "effect";
+import { CoreV1Api, CustomObjectsApi, KubeConfig } from "@kubernetes/client-node";
+
+//#region src/runtime/services/kubernetes-argo-service.d.ts
+type CoreApi = Pick<CoreV1Api, "createNamespacedConfigMap">;
+type WorkflowApi = Pick<CustomObjectsApi, "createNamespacedCustomObject">;
+interface KubernetesArgoIoDependencies {
+  coreApi?: CoreApi;
+  kubeConfig?: KubeConfig;
+  workflowApi?: WorkflowApi;
+}
+//#endregion
+export { CoreApi, KubernetesArgoIoDependencies, WorkflowApi };

package/dist/runtime/services/kubernetes-argo-service.js

@@ -0,0 +1,81 @@
+import { Context, Effect, Layer } from "effect";
+import { execa } from "execa";
+import { CoreV1Api, CustomObjectsApi, KubeConfig } from "@kubernetes/client-node";
+//#region src/runtime/services/kubernetes-argo-service.ts
+var KubernetesArgoService = class extends Context.Tag("KubernetesArgoService")() {};
+const KubernetesArgoServiceLive = Layer.succeed(KubernetesArgoService, {
+	createConfigMap: ({ body, dependencies, namespace, options }) => Effect.try({
+		try: () => apiClients(options, dependencies),
+		catch: (error) => error
+	}).pipe(Effect.flatMap(({ coreApi }) => Effect.tryPromise({
+		try: () => coreApi.createNamespacedConfigMap({
+			body,
+			namespace
+		}),
+		catch: (error) => error
+	}))),
+	createWorkflow: ({ body, dependencies, namespace, options }) => Effect.try({
+		try: () => apiClients(options, dependencies),
+		catch: (error) => error
+	}).pipe(Effect.flatMap(({ workflowApi }) => Effect.tryPromise({
+		try: () => workflowApi.createNamespacedCustomObject({
+			body,
+			group: "argoproj.io",
+			namespace,
+			plural: "workflows",
+			version: "v1alpha1"
+		}),
+		catch: (error) => error
+	}))),
+	kubectl: (args, options) => Effect.tryPromise({
+		try: () => execa("kubectl", kubectlArgs(args, options.kubeContext), {
+			env: options.kubeconfigPath ? { KUBECONFIG: options.kubeconfigPath } : void 0,
+			stdin: "ignore"
+		}),
+		catch: (error) => error
+	}).pipe(Effect.map((result) => ({
+		ok: true,
+		stderr: result.stderr,
+		stdout: result.stdout
+	})), Effect.catchAll((error) => Effect.succeed({
+		ok: false,
+		stderr: kubectlErrorStderr(error),
+		stdout: kubectlErrorStdout(error)
+	})))
+});
+function resolveKubeConfig(options, dependencies) {
+	if (dependencies.kubeConfig) return dependencies.kubeConfig;
+	const kubeConfig = new KubeConfig();
+	if (options.kubeconfigPath) kubeConfig.loadFromFile(options.kubeconfigPath);
+	else kubeConfig.loadFromDefault();
+	return kubeConfig;
+}
+function apiClients(options, dependencies) {
+	if (dependencies.coreApi && dependencies.workflowApi) return {
+		coreApi: dependencies.coreApi,
+		workflowApi: dependencies.workflowApi
+	};
+	return buildApiClients(resolveKubeConfig(options, dependencies), dependencies);
+}
+function buildApiClients(kubeConfig, dependencies) {
+	return {
+		coreApi: dependencies.coreApi ?? kubeConfig.makeApiClient(CoreV1Api),
+		workflowApi: dependencies.workflowApi ?? kubeConfig.makeApiClient(CustomObjectsApi)
+	};
+}
+function kubectlArgs(args, kubeContext) {
+	return kubeContext ? [
+		"--context",
+		kubeContext,
+		...args
+	] : [...args];
+}
+function kubectlErrorStderr(error) {
+	const parsed = error;
+	return (parsed.stderr || parsed.shortMessage || "kubectl failed").trim();
+}
+function kubectlErrorStdout(error) {
+	return (error.stdout || "").trim();
+}
+//#endregion
+export { KubernetesArgoService, KubernetesArgoServiceLive };