@cloud-cli/on 1.59.0 → 1.60.0

package/dist/worker-riimPLUr.js

@@ -0,0 +1,895 @@
+import { t as e } from "./timestamped-log-Dtz_Euu0.js";
+import { t } from "./workflow-registry-D4IciIF7.js";
+import { a as n, i as r, r as i, t as a } from "./matrix-expander-BItKqWu2.js";
+import { t as o } from "./secrets-BR6K16WY.js";
+import { n as s } from "./events-BoODn7MY.js";
+import { n as c } from "./workflows-Dm_0dWb_.js";
+import l from "node:fs";
+import u from "node:path";
+import { promisify as d } from "node:util";
+import { exec as f, spawn as p } from "node:child_process";
+import { readFile as m } from "node:fs/promises";
+//#region src/drivers/systemd.driver.ts
+var h = d(f), g = class {
+	name = "systemd";
+	async isSupported() {
+		try {
+			return l.existsSync("/run/systemd/system");
+		} catch {
+			return !1;
+		}
+	}
+	execute(t) {
+		let r = null, i = null, a = Date.now(), o = u.join(t.logsDir, `step-${t.step.id}.log`);
+		try {
+			l.mkdirSync(t.logsDir, { recursive: !0 }), l.mkdirSync(t.workingDir, { recursive: !0 }), l.chmodSync(t.workingDir, 511), r = l.openSync(o, "a"), i = new e(r);
+		} catch (e) {
+			return {
+				done: Promise.resolve({
+					exitCode: 1,
+					durationMs: 0,
+					error: /* @__PURE__ */ Error(`Failed to initialize step log file: ${e.message}`)
+				}),
+				cancel: async () => {},
+				logFilePath: ""
+			};
+		}
+		let s = `workflow-${t.jobId}-${t.step.id}-attempt-${t.attempt || 1}-${Date.now()}`.replace(/[^a-zA-Z0-9_-]/g, "_"), c = [
+			`--unit=${s}`,
+			"--wait",
+			"--pipe",
+			"--collect",
+			"-p",
+			"RemainAfterExit=no",
+			`--working-directory=${t.workingDir}`
+		], d = {
+			...t.env || {},
+			PATH: t.env?.PATH || process.env.PATH
+		};
+		for (let [e, t] of Object.entries(d)) c.push(`--setenv=${e}=${t}`);
+		if (t.timeoutMs) {
+			let e = Math.ceil(t.timeoutMs / 1e3);
+			c.push(`--property=RuntimeMaxSec=${e}`);
+		}
+		let f;
+		t.image ? (c.push("--setenv=WORKING_DIR=/workspace"), f = [
+			"docker",
+			"run",
+			"--rm",
+			"--init",
+			`--name=${s}`,
+			...t.volumes?.flatMap((e) => ["-v", e]) || [],
+			"-v",
+			`${t.workingDir}:/workspace`,
+			"-w",
+			"/workspace",
+			...Object.keys(d).filter((e) => e !== "PATH").flatMap((e) => ["-e", e]),
+			"--entrypoint",
+			"/bin/sh",
+			...t.dockerArgs || [],
+			t.image,
+			"-e",
+			"-c",
+			t.command
+		]) : (c.push(`--setenv=WORKING_DIR=${t.workingDir}`), f = [
+			process.env.SHELL || "sh",
+			"-e",
+			"-c",
+			t.command
+		]), n("$ systemd-run", [
+			...c,
+			"--",
+			...f
+		].join(" "));
+		let m;
+		try {
+			m = p("systemd-run", [
+				...c,
+				"--",
+				...f
+			], { stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			] }), m.stdout?.on("data", (e) => i?.write(e)), m.stderr?.on("data", (e) => i?.write(e));
+		} catch (e) {
+			try {
+				l.closeSync(r);
+			} catch {}
+			return {
+				done: Promise.resolve({
+					exitCode: 1,
+					durationMs: Date.now() - a,
+					error: /* @__PURE__ */ Error(`Failed to spawn systemd-run: ${e.message}`)
+				}),
+				cancel: async () => {},
+				logFilePath: o
+			};
+		}
+		let g = !1;
+		return {
+			done: new Promise((e) => {
+				let t = !1, n = (n) => {
+					t || (t = !0, i?.end(() => {
+						try {
+							l.closeSync(r);
+						} catch {}
+						e(n);
+					}));
+				};
+				m.on("close", (e, t) => {
+					n({
+						exitCode: e === null ? t ? g ? 130 : 1 : 0 : e,
+						durationMs: Date.now() - a,
+						error: g ? /* @__PURE__ */ Error("Step cancelled by user or systemd timeout") : void 0
+					});
+				}), m.on("error", (e) => {
+					n({
+						exitCode: 1,
+						durationMs: Date.now() - a,
+						error: e
+					});
+				});
+			}),
+			cancel: async () => {
+				g = !0;
+				try {
+					t.image && await h(`docker stop -t 2 ${s}`).catch(() => {}), await h(`systemctl stop ${s}.service`).catch(() => {});
+				} catch {}
+			},
+			logFilePath: o
+		};
+	}
+	async readLog(e) {
+		let t = await m(e, "utf-8"), n = t.includes("Running as unit: ") ? t.indexOf("\n") + 1 : 0, r = t.includes("Finished with result: ") ? t.lastIndexOf("Finished with result: ") : t.length;
+		return t.slice(n, r);
+	}
+}, _ = class {
+	name = "standard-process";
+	async isSupported() {
+		return !0;
+	}
+	execute(t) {
+		let r = null, i = null, a = Date.now(), o = u.join(t.logsDir, `step-${t.step.id}.log`);
+		try {
+			l.mkdirSync(t.logsDir, { recursive: !0 }), l.mkdirSync(t.workingDir, { recursive: !0 }), l.chmodSync(t.workingDir, 511), r = l.openSync(o, "a"), i = new e(r);
+		} catch (e) {
+			return {
+				done: Promise.resolve({
+					exitCode: 1,
+					durationMs: 0,
+					error: /* @__PURE__ */ Error(`Failed to initialize step log file: ${e.message}`)
+				}),
+				cancel: async () => {},
+				logFilePath: ""
+			};
+		}
+		let s, c, d = { ...t.env };
+		t.image ? (d.WORKING_DIR = "/workspace", s = "docker", c = [
+			"run",
+			"--rm",
+			"--init",
+			"-v",
+			`${t.workingDir}:/workspace`,
+			"-w",
+			"/workspace",
+			"--entrypoint",
+			"/bin/sh",
+			...t.volumes?.flatMap((e) => ["-v", e]) || [],
+			...t.dockerArgs || [],
+			...Object.keys(d).filter((e) => e !== "PATH").flatMap((e) => ["-e", e]),
+			t.image,
+			"-c",
+			t.command
+		]) : (d.WORKING_DIR = t.workingDir, s = process.env.SHELL || "sh", c = [
+			"-e",
+			"-c",
+			t.command
+		]), n("$ " + s, c.join(" "));
+		let f;
+		try {
+			f = p(s, c, {
+				cwd: t.workingDir,
+				env: d,
+				detached: !0,
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				]
+			}), f.stdout?.on("data", (e) => i?.write(e)), f.stderr?.on("data", (e) => i?.write(e));
+		} catch (e) {
+			try {
+				l.closeSync(r);
+			} catch {}
+			return {
+				done: Promise.resolve({
+					exitCode: 1,
+					durationMs: Date.now() - a,
+					error: /* @__PURE__ */ Error(`Failed to spawn process: ${e.message}`)
+				}),
+				cancel: async () => {},
+				logFilePath: o
+			};
+		}
+		let m = !1, h = null;
+		return {
+			done: new Promise((e) => {
+				let n = !1, o = (t) => {
+					n || (n = !0, h && clearTimeout(h), i?.end(() => {
+						try {
+							l.closeSync(r);
+						} catch {}
+						e(t);
+					}));
+				};
+				t.timeoutMs && (h = setTimeout(() => {
+					m = !0, this.killProcessGroup(f);
+				}, t.timeoutMs), h.unref()), f.on("close", (e) => {
+					o({
+						exitCode: e ?? (m ? 130 : 1),
+						durationMs: Date.now() - a,
+						error: m ? /* @__PURE__ */ Error("Step timed out or was cancelled by user") : void 0
+					});
+				}), f.on("error", (e) => {
+					o({
+						exitCode: 1,
+						durationMs: Date.now() - a,
+						error: e
+					});
+				});
+			}),
+			cancel: async () => {
+				m = !0, this.killProcessGroup(f);
+			},
+			logFilePath: o
+		};
+	}
+	killProcessGroup(e) {
+		if (e.pid && !e.killed) try {
+			process.kill(-e.pid, "SIGTERM"), setTimeout(() => {
+				try {
+					e.pid && !e.killed && process.kill(-e.pid, "SIGKILL");
+				} catch {}
+			}, 5e3).unref();
+		} catch {}
+	}
+	async readLog(e) {
+		return m(e, "utf-8");
+	}
+};
+//#endregion
+//#region src/drivers/index.ts
+async function v() {
+	let e = new g();
+	return await e.isSupported() ? (console.log("⚡ Selected Execution Driver: Systemd (cgroups enabled)"), e) : (console.log("📦 Selected Execution Driver: Standard Process (Fallback)"), new _());
+}
+//#endregion
+//#region src/signals.ts
+async function y(e) {
+	let t = !1;
+	async function n(n) {
+		if (!t) {
+			t = !0, console.log(`\n🛑 Received ${n}. Initiating graceful shutdown...`);
+			try {
+				D(), e.length > 0 && (console.log("⚙️ Waiting for active worker jobs to drain..."), await Promise.allSettled(e)), console.log("✨ Engine stopped cleanly. Goodbye!"), process.exit(0);
+			} catch (e) {
+				console.error("❌ Error during graceful shutdown:", e.message), process.exit(1);
+			}
+		}
+	}
+	process.on("SIGINT", () => n("SIGINT")), process.on("SIGTERM", () => n("SIGTERM")), process.on("SIGUSR1", () => n("SIGUSR1"));
+}
+//#endregion
+//#region src/plugins/manager.ts
+var b = class {
+	plugins;
+	constructor(e = []) {
+		this.plugins = e;
+	}
+	register(e) {
+		console.log(`🔌 Registered Plugin: ${e.name}`), this.plugins.push(e);
+	}
+	async triggerWorkflowStart(e) {
+		for (let t of this.plugins) if (t.onWorkflowStart) try {
+			await t.onWorkflowStart(e);
+		} catch (e) {
+			console.error(`[Plugin Error] ${t.name}.onWorkflowStart:`, e);
+		}
+	}
+	async triggerWorkflowFinish(e, t) {
+		for (let n of this.plugins) if (n.onWorkflowFinish) try {
+			await n.onWorkflowFinish(e, t);
+		} catch (e) {
+			console.error(`[Plugin Error] ${n.name}.onWorkflowFinish:`, e);
+		}
+	}
+}, x = {
+	name: "@cloud-cli/on",
+	version: "0.0.0",
+	description: "CLI entry point for the on plugin ecosystem.",
+	type: "module",
+	packageManager: "pnpm@12.3.4",
+	license: "MIT",
+	exports: { ".": {
+		types: "./dist/index.d.ts",
+		default: "./dist/on.js"
+	} },
+	files: ["dist"],
+	main: "dist/on.js",
+	bin: { on: "dist/on.js" },
+	dependencies: {
+		acorn: "^8.18.0",
+		openai: "7.15.0",
+		"web-push": "^3.6.7",
+		yaml: "^2.9.0"
+	},
+	scripts: {
+		ci: "pnpm build && pnpm lint && pnpm test",
+		build: "vite build && tsc --emitDeclarationOnly --declaration",
+		lint: "eslint .",
+		test: "vitest run",
+		"test:e2e": "docker build --no-cache -t on:e2e . && node tests/docker-smoke.mjs",
+		release: "npx --yes semantic-release@24 -b main --no-ci"
+	},
+	devDependencies: {
+		"@changesets/cli": "^2.31.1",
+		"@eslint/js": "^10.0.1",
+		"@types/node": "^26.5.1",
+		"@types/web-push": "^3.6.4",
+		"@typescript-eslint/eslint-plugin": "^8.70.0",
+		"@typescript-eslint/parser": "^8.70.0",
+		eslint: "10.8.0",
+		marked: "^18.0.12",
+		tsx: "4.23.13",
+		typescript: "6.0.3",
+		"typescript-eslint": "8.70.0",
+		vite: "8.2.0",
+		vitest: "4.1.11"
+	}
+}.version, S = { isStopping: !1 }, C = /* @__PURE__ */ new Set(), w = null, T = null;
+async function E() {
+	C.size && (console.log("⚡ Cancelling active step execution handles due to worker shutdown..."), await Promise.allSettled(Array.from(C, (e) => e.cancel())), C.clear());
+}
+function D() {
+	S.isStopping = !0, w?.abort(), T?.();
+}
+function O(e, t, n, r) {
+	S.isStopping = !1;
+	let i = [k(e, t, n, r)];
+	return y(i), i;
+}
+async function k(e, t, n, r) {
+	let i = await v(), a = new c(), s = /* @__PURE__ */ new Set(), l = 0, u = null, d = () => {
+		l++, u?.();
+	}, f = process.env.WORKER_NAME || "cli";
+	T = d, w = new AbortController();
+	let p = A(r, w.signal, d), m = setInterval(() => void P(r, f, e, s.size), 15e3);
+	for (m.unref(), P(r, f, e, s.size), console.log(`🚀 Worker scheduler started. Driver: ${i.name}. Concurrency: ${e}. Tags: ${r.tags.join(", ") || "(none)"}`); !S.isStopping;) {
+		let n = l;
+		try {
+			for (; s.size < e && !S.isStopping;) {
+				let e = await t.claimNextJob(r.tags);
+				if (!e) break;
+				if (S.isStopping) {
+					await t.releaseJob(e.id);
+					break;
+				}
+				let n;
+				n = (async () => {
+					N(r, e.id);
+					let n = await a.getRevision(e.workflow_id, e.workflow_revision);
+					if (!n) throw await t.finishJob(e.id, "failed"), Error(`Workflow ${e.workflow_id} revision ${e.workflow_revision} was not found`);
+					let s = new o();
+					s.replace(await F(r, f, e.id)), await I({
+						workerId: f,
+						job: e,
+						queue: t,
+						secrets: s,
+						config: r,
+						driver: i,
+						workflow: n
+					});
+				})().catch((e) => console.error(`[${f}] ⚠️ Worker execution error:`, e)).finally(() => {
+					s.delete(n), N(r, e.id), d();
+				}), s.add(n);
+			}
+		} catch (e) {
+			console.error("⚠️ Worker scheduler claim error:", e), setTimeout(d, 5e3).unref();
+		}
+		!S.isStopping && l === n && (await j(n, () => l, (e) => u = e), u = null);
+	}
+	w.abort(), clearInterval(m), await Promise.allSettled(s), await p, T = null, console.log("🛑 Worker scheduler stopped cleanly.");
+}
+async function A(e, t, n) {
+	let r = 1e3;
+	for (; !t.aborted;) {
+		try {
+			await s(e.serverUrl, t, (t, r) => {
+				t === "jobs.available" && (Array.isArray(r.tags) ? r.tags.filter((e) => typeof e == "string") : []).every((t) => e.tags.includes(t)) && n();
+			}, n), r = 1e3;
+		} catch (e) {
+			if (t.aborted || e?.name === "AbortError") break;
+			console.error(`⚠️ Worker event stream disconnected: ${e.message}`);
+		}
+		await M(r, t), r = Math.min(r * 2, 3e4);
+	}
+}
+function j(e, t, n) {
+	return new Promise((r) => {
+		if (t() !== e) return r();
+		let i = setTimeout(r, 6e4);
+		n(() => {
+			clearTimeout(i), r();
+		});
+	});
+}
+function M(e, t) {
+	return new Promise((n) => {
+		if (t.aborted) return n();
+		let r = () => {
+			clearTimeout(i), n();
+		}, i = setTimeout(() => {
+			t.removeEventListener("abort", r), n();
+		}, e);
+		t.addEventListener("abort", r, { once: !0 });
+	});
+}
+async function N(e, t) {
+	if (e.workerToken) try {
+		let r = await fetch(new URL("/api/events", e.serverUrl), {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${e.workerToken}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({ jobId: t }),
+			signal: AbortSignal.timeout(5e3)
+		});
+		r.ok || n(`Failed to publish job status event: HTTP ${r.status}`);
+	} catch (e) {
+		n("Failed to publish job status event:", e);
+	}
+}
+async function P(e, t, r, i) {
+	if (e.workerToken) try {
+		await fetch(new URL("/api/workers/heartbeat", e.serverUrl), {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${e.workerToken}`,
+				"Content-Type": "application/json",
+				"X-Runner-Worker-Id": t
+			},
+			body: JSON.stringify({
+				workerId: t,
+				version: x,
+				tags: e.tags,
+				concurrency: r,
+				activeJobs: i
+			}),
+			signal: AbortSignal.timeout(5e3)
+		});
+	} catch (e) {
+		n("Failed to publish worker heartbeat:", e);
+	}
+}
+async function F(e, t, n) {
+	if (!e.workerToken) return {};
+	try {
+		let r = await fetch(new URL(`/api/jobs/${n}/secrets`, e.serverUrl), {
+			headers: {
+				Authorization: `Bearer ${e.workerToken}`,
+				"X-Runner-Worker-Id": t
+			},
+			signal: AbortSignal.timeout(5e3)
+		});
+		if (!r.ok) throw Error(`HTTP ${r.status}`);
+		return (await r.json()).secrets || {};
+	} catch (e) {
+		throw console.error(`Unable to retrieve secrets for job ${n}:`, e), e;
+	}
+}
+async function I(e) {
+	let { workerId: n, job: o, config: s, secrets: c, queue: l } = e;
+	console.log(`\n[${n}] 📦 Claimed Job #${o.id} (Workflow: ${o.workflow_id})`);
+	let d = typeof o.payload == "string" ? JSON.parse(o.payload) : o.payload;
+	if (!e.workflow) throw Error(`Workflow ${o.workflow_id} revision ${o.workflow_revision} was not resolved`);
+	let f = d.matrix ? a(e.workflow).find((e) => JSON.stringify(e.matrixContext) === JSON.stringify(d.matrix)) : e.workflow;
+	if (!f) throw Error(`Matrix variant for job ${o.id} was not found`);
+	let p = f, m = {
+		...e,
+		workflow: p
+	}, h = p.steps, g = d.inputs || {}, _ = Date.now(), v = u.join(s.storagePath, `job-${o.id}`), y = u.join(v, "logs"), x = u.join(v, "wd"), S = {
+		inputs: g,
+		env: {
+			...s.env,
+			CI: "true",
+			CI_JOB_ID: String(o.id),
+			CI_JOB_NAME: p.name
+		},
+		secrets: c.getAll(),
+		steps: {},
+		logsDir: y,
+		workingDir: x,
+		files: r(x)
+	}, C = "", w = h.map((e, t) => (e.id ||= `step-${t}`, e.name ||= e.id, {
+		id: e.id,
+		name: e.name,
+		status: "pending",
+		durationMs: 0,
+		outputs: {},
+		logContent: ""
+	})), T = X(o, "running", _, g, S.env, w, d);
+	await l.saveReport(o.id, T), N(s, o.id);
+	try {
+		Object.assign(S.env, await B(p.env, S)), Object.assign(S.env, {
+			CI: "true",
+			CI_JOB_ID: String(o.id),
+			CI_JOB_NAME: p.name
+		}), q(p.secretFiles, c, x), C = p.cache ? String(await i.evaluateValue(p.cache.key, S)) : "", C && p.cache && await K(l, "cache", `${o.workflow_id}:${C}`, p.cache.paths, x), await l.saveReport(o.id, T);
+	} catch (e) {
+		T.status = "failed", T.finishedAt = (/* @__PURE__ */ new Date()).toISOString(), T.durationMs = Date.now() - _;
+		let t = {
+			...T,
+			steps: T.steps.map((e) => ({
+				...e,
+				status: "skipped"
+			}))
+		};
+		await l.completeJob(o.id, "failed", t), console.error(`[${n}] ❌ Job setup failed:`, e);
+		return;
+	}
+	let E = [...s.plugins];
+	for (let e of p.plugins || []) try {
+		let n = await B(e.secrets, S);
+		E.push(t({
+			...e,
+			secrets: n
+		}));
+	} catch (t) {
+		console.error(`[${n}] Workflow plugin '${e.name}' failed to initialize:`, t);
+	}
+	let D = new b(E), O = {
+		jobId: String(o.id),
+		workflowName: p.name,
+		inputs: g,
+		runUrl: new URL(`/runs/${o.id}`, s.serverUrl).toString()
+	};
+	await D.triggerWorkflowStart(O);
+	let { cancelled: k, failed: A } = await L({
+		payload: d,
+		steps: h,
+		executionContext: S,
+		...m
+	}, T), j = k ? "cancelled" : A ? "failed" : "success";
+	if (j === "success") try {
+		let e = p.artifacts ? await G(p.artifacts.paths, x) : [];
+		if (e.length && (await l.saveStoredFiles("artifact", String(o.id), e), T.artifacts = e.map((e) => e.path)), C && p.cache) {
+			let e = await G(p.cache.paths, x);
+			e.length && await l.saveStoredFiles("cache", `${o.workflow_id}:${C}`, e);
+		}
+	} catch (e) {
+		console.error(`[${n}] ⚠️ Failed to store workflow files:`, e), j = "failed";
+	}
+	T.status = j, T.durationMs = Date.now() - _, T.finishedAt = (/* @__PURE__ */ new Date()).toISOString(), await l.completeJob(o.id, j, T), N(s, o.id), console.log(`[${n}] ✅ Job #${o.id} completed as: ${j}`), await D.triggerWorkflowFinish(O, j);
+}
+async function L(e, t) {
+	let { driver: n, workerId: r, queue: i, config: a, job: o, payload: s, steps: c, executionContext: l } = e, u = t.steps, d = !1, f = !1, p = 0;
+	try {
+		for (let s = 0; s < c.length; s++) {
+			let m = c[s], h = (/* @__PURE__ */ new Date()).toISOString();
+			u[s] = {
+				...u[s],
+				status: "running",
+				durationMs: 0,
+				exitCode: void 0,
+				error: void 0,
+				outputs: {},
+				logContent: "",
+				startedAt: h,
+				finishedAt: void 0
+			}, t.durationMs = Date.now() - Date.parse(t.startedAt), await i.saveReport(o.id, t), N(a, o.id);
+			let g = {
+				failed: !0,
+				skipped: !1,
+				cancelled: !1,
+				report: null
+			}, _ = e.workflow?.retries ?? 0;
+			for (let e = 1; e <= _ + 1 && (g = await R({
+				workerId: r,
+				jobId: o.id,
+				step: m,
+				stepIndex: s,
+				attempt: e,
+				executionContext: l,
+				driver: n,
+				queue: i,
+				config: a
+			}), !(!g.failed || g.cancelled || e > _)); e++) console.log(`[${r}] 🔁 Retrying step [${m.id}] (${e}/${_ + 1})`);
+			if (g.report ? u[s] = {
+				...g.report,
+				startedAt: h,
+				finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+			} : g.skipped ? u[s] = {
+				...u[s],
+				status: "skipped",
+				durationMs: 0,
+				exitCode: 0,
+				finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+			} : u[s] = {
+				...u[s],
+				status: "failed",
+				durationMs: 0,
+				exitCode: 1,
+				error: "Step failed before execution started",
+				finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}, p = s + 1, t.durationMs = Date.now() - Date.parse(t.startedAt), await i.saveReport(o.id, t), N(a, o.id), g.skipped) break;
+			if (g.cancelled) {
+				f = !0, d = !0;
+				break;
+			}
+			if (g.failed) {
+				d = !0;
+				break;
+			}
+		}
+	} catch (e) {
+		console.log("🛑 Step failed", e), d = !0;
+	}
+	return p < c.length && (Y(c, p, u), t.durationMs = Date.now() - Date.parse(t.startedAt), await i.saveReport(o.id, t), N(a, o.id)), {
+		failed: d,
+		cancelled: f,
+		stepReports: u
+	};
+}
+async function R(e) {
+	let { step: t, stepIndex: r, executionContext: a } = e;
+	if (t.id ||= `step-${r}`, t.name ||= t.id, t.if && !await i.evaluateConditions(t.if, a)) return n(`⏩ Skipped step ${t.id} based on condition: ${t.if}`, a), {
+		failed: !1,
+		cancelled: !1,
+		skipped: !0,
+		report: null
+	};
+	try {
+		let n = await B(t.env, a), i = {
+			jobId: String(e.jobId),
+			step: t,
+			command: t.run,
+			timeoutMs: t.timeoutMs ?? 3e4,
+			attempt: e.attempt,
+			image: t.image,
+			volumes: t.volumes,
+			dockerArgs: t.dockerArgs,
+			workingDir: a.workingDir,
+			logsDir: a.logsDir,
+			env: {
+				...a.env,
+				...n,
+				WORKING_DIR: a.workingDir,
+				CI: "true",
+				CI_JOB_ID: String(e.jobId),
+				CI_JOB_NAME: a.env.CI_JOB_NAME || t.name || t.id || `step-${r}`
+			}
+		};
+		return t.eval ? z({
+			...e,
+			stepContext: i
+		}) : J({
+			...e,
+			stepContext: i
+		});
+	} catch (r) {
+		let i = r?.message || String(r);
+		return await e.queue.saveStepLog(e.jobId, t.id, `[STEP ERROR]:\n${i}`), n(`⏩ Failed to run step ${t.id}`, a, r), {
+			failed: !0,
+			cancelled: !1,
+			skipped: !1,
+			report: {
+				id: t.id,
+				name: t.name,
+				status: "failed",
+				durationMs: 0,
+				exitCode: 1,
+				error: i,
+				outputs: {},
+				logContent: ""
+			}
+		};
+	}
+}
+async function z(e) {
+	let { queue: t, stepContext: n, executionContext: r } = e, { jobId: a, step: o } = n, s = Date.now(), c = o.id, l = o.name, u;
+	try {
+		let e = new Promise((e, t) => {
+			u = setTimeout(() => t(/* @__PURE__ */ Error(`Step timed out after ${n.timeoutMs}ms`)), n.timeoutMs), u.unref();
+		}), d = await Promise.race([i.evaluateExpression(o.eval, r), e]);
+		r.steps[c] = {
+			status: "success",
+			exitCode: 0,
+			outputs: d ?? {}
+		};
+		let f = typeof d == "object" ? JSON.stringify(d, null, 2) : String(d ?? "OK");
+		return await t.saveStepLog(a, c, `[JS EVAL OUTPUT]:\n${f}`), console.log(`[${c}] ✅ JS Eval step complete.`), {
+			failed: !1,
+			cancelled: !1,
+			skipped: !1,
+			report: {
+				id: c,
+				name: l,
+				status: "success",
+				durationMs: Date.now() - s,
+				exitCode: 0,
+				outputs: r.steps[c].outputs,
+				logContent: ""
+			}
+		};
+	} catch (e) {
+		return console.error(`[${c}] ❌ JS Eval step failed:`, e), r.steps[c] = {
+			status: "failed",
+			exitCode: 1,
+			outputs: {}
+		}, await t.saveStepLog(a, c, `[JS EVAL ERROR]:\n${e.message}`), {
+			failed: !0,
+			cancelled: !1,
+			skipped: !1,
+			report: {
+				id: c,
+				name: l,
+				status: "failed",
+				durationMs: Date.now() - s,
+				exitCode: 1,
+				error: e.message,
+				outputs: {},
+				logContent: ""
+			}
+		};
+	} finally {
+		u && clearTimeout(u);
+	}
+}
+async function B(e, t) {
+	let n = {};
+	if (e) for (let [r, a] of Object.entries(e)) n[r] = String(await i.evaluateValue(a, {
+		...t,
+		env: {
+			...t.env,
+			...n
+		}
+	}));
+	return n;
+}
+var V = 52428800;
+function H(e, t) {
+	let n = u.resolve(e), r = u.resolve(n, t);
+	if (r !== n && !r.startsWith(`${n}${u.sep}`)) throw Error(`Stored file path escapes workspace: ${t}`);
+	return r;
+}
+function U(e, t) {
+	let n = "^";
+	for (let e = 0; e < t.length; e++) t[e] === "*" && t[e + 1] === "*" ? (n += ".*", e++) : t[e] === "*" ? n += "[^/]*" : n += t[e].replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+	return RegExp(`${n}$`).test(e);
+}
+function W(e, t) {
+	let n = u.resolve(t), r = [], i = (e) => {
+		for (let t of l.readdirSync(e, { withFileTypes: !0 })) {
+			let a = u.join(e, t.name);
+			t.isDirectory() ? i(a) : t.isFile() && r.push(u.relative(n, a).split(u.sep).join("/"));
+		}
+	};
+	return i(n), r.filter((n) => e.some((e) => {
+		let r = H(t, e);
+		if (l.existsSync(r)) {
+			let t = l.statSync(r);
+			if (t.isFile()) return n === e;
+			if (t.isDirectory()) return n === e || n.startsWith(`${e.replace(/\/$/, "")}/`);
+		}
+		return U(n, e);
+	}));
+}
+async function G(e, t) {
+	let n = W(e, t), r = 0;
+	return n.map((e) => {
+		let n = l.readFileSync(H(t, e));
+		if (n.byteLength > V || (r += n.byteLength) > V) throw Error(`Stored files exceed ${V} bytes`);
+		return {
+			path: e,
+			content: n.toString("base64")
+		};
+	});
+}
+async function K(e, t, n, r, i) {
+	for (let a of await e.getStoredFiles(t, n)) {
+		if (!r.some((e) => a.path === e || a.path.startsWith(`${e.replace(/\/$/, "")}/`) || U(a.path, e))) continue;
+		let e = H(i, a.path);
+		l.mkdirSync(u.dirname(e), { recursive: !0 }), l.writeFileSync(e, Buffer.from(a.content, "base64"));
+	}
+}
+function q(e, t, n) {
+	for (let [r, i] of Object.entries(e || {})) {
+		let e = t.getValue(i);
+		if (!e) throw Error(`Secret '${i}' is not available for file '${r}'`);
+		let a = H(n, r);
+		l.mkdirSync(u.dirname(a), { recursive: !0 }), l.writeFileSync(a, e.encoding === "base64" ? Buffer.from(e.value, "base64") : e.value, { mode: 384 }), l.chmodSync(a, 384);
+	}
+}
+async function J(e) {
+	let { workerId: t, jobId: n, stepContext: r, executionContext: i, driver: a, queue: o } = e, { step: s } = r, c = s.id, u = s.name, d;
+	try {
+		d = a.execute(r);
+	} catch (e) {
+		d = {
+			done: Promise.resolve({
+				exitCode: 1,
+				durationMs: 0,
+				error: Error(String(e))
+			}),
+			cancel: async () => {},
+			logFilePath: ""
+		};
+	}
+	C.add(d);
+	let f = !1, p = setInterval(async () => {
+		await o.isCancelled(n) && (console.log(`[${t}] 🛑 Job #${n} was cancelled! Halting execution.`), f = !0, clearInterval(p), await d.cancel());
+	}, 3e3), m = await d.done;
+	if (clearInterval(p), C.delete(d), d.logFilePath && l.existsSync(d.logFilePath)) try {
+		let e = await a.readLog(d.logFilePath);
+		await o.saveStepLog(n, c, e);
+	} catch (e) {
+		console.error(`[${t}] ⚠️ Failed to read step log file:`, e.message);
+	}
+	let h = m.exitCode !== 0 || f, g = f ? "cancelled" : m.exitCode === 0 ? "success" : "failed";
+	return i.steps[c] = {
+		status: g,
+		exitCode: m.exitCode,
+		outputs: {}
+	}, h && console.error(`[${t}] ❌ Step [${c}] finished with status: ${g}`), {
+		failed: h,
+		cancelled: f,
+		skipped: !1,
+		report: {
+			id: c,
+			name: u,
+			status: g,
+			durationMs: m.durationMs,
+			exitCode: m.exitCode,
+			error: m.error?.message,
+			outputs: {},
+			logContent: ""
+		}
+	};
+}
+function Y(e, t, n) {
+	for (let r = t; r < e.length; r++) {
+		let t = e[r], i = t.id || `step-${r}`;
+		n[r] = {
+			id: i,
+			name: t.name || i,
+			status: "skipped",
+			durationMs: 0,
+			exitCode: 0,
+			outputs: {},
+			logContent: ""
+		};
+	}
+}
+function X(e, t, n, r, i, a, o) {
+	return {
+		jobId: String(e.id),
+		parentId: String(e.parentId || ""),
+		workflowName: e.workflow_id,
+		status: t,
+		durationMs: Date.now() - n,
+		startedAt: new Date(n).toISOString(),
+		finishedAt: t === "running" ? void 0 : (/* @__PURE__ */ new Date()).toISOString(),
+		inputs: r,
+		environment: i,
+		steps: a,
+		artifacts: [],
+		rerunToken: JSON.stringify({
+			jobId: e.id,
+			payload: o
+		})
+	};
+}
+//#endregion
+export { E as abortActiveWorkerTask, I as processJob, D as requestWorkerShutdown, S as shutdownState, k as startWorkerScheduler, O as startWorkers };