@kici-dev/compiler 0.1.26 → 0.1.27

package/dist/local-executor/job-runner.js

@@ -1,411 +0,0 @@
-import "../rolldown-runtime-ClRpJifh.js";
-import { ensureTsLoaderHook } from "../execution/ts-loader.js";
-import { formatter } from "../test-runner/output-formatter.js";
-import { createStepContext } from "../test-runner/step-context.js";
-import { createRuleContext, evaluateRules as evaluateRulesWithFormatting } from "../test-runner/rule-evaluator.js";
-import { localRunsOnString } from "./runs-on-display.js";
-import { toEventPayload } from "./to-event-payload.js";
-import { pathToFileURL } from "node:url";
-import path from "node:path";
-import { applyIncludeExclude, expandMatrix, flattenStepInputs, isDynamicJobFn, setJobOutputsMap, setStepOutputsMap, setStepRefMap } from "@kici-dev/sdk";
-import { computeBackoffDelay } from "@kici-dev/core";
-import { CheckMode, CheckStepOutcome, formatMatrixSuffix } from "@kici-dev/engine";
-import { runIdempotentStep } from "@kici-dev/core/idempotency";
-//#region src/local-executor/job-runner.ts
-/**
-* Job resolution (matrix/dynamic) and single-job execution with step context.
-*
-* Handles:
-* - Static job resolution
-* - Matrix expansion into multiple ResolvedJob instances
-* - Dynamic job function evaluation
-* - Single-job step-by-step execution with rules, abort, and output chaining
-*/
-/**
-* Resolve SDK output setter functions from the workflow's module instance.
-* Ensures output maps are set on the same SDK module the workflow code uses.
-*/
-async function resolveSdkSetters(kiciDir) {
-	if (kiciDir) try {
-		const sdkUrl = pathToFileURL(path.join(kiciDir, "node_modules", "@kici-dev", "sdk", "dist", "index.js")).href;
-		ensureTsLoaderHook();
-		const sdk = await import(sdkUrl);
-		return {
-			setStepOutputsMap: sdk.setStepOutputsMap,
-			setStepRefMap: sdk.setStepRefMap,
-			setJobOutputsMap: sdk.setJobOutputsMap
-		};
-	} catch {}
-	return {
-		setStepOutputsMap,
-		setStepRefMap,
-		setJobOutputsMap
-	};
-}
-/**
-* Resolve a needs entry to a string name.
-* Handles Job objects, strings, DynamicGroupRef, and object forms.
-*/
-function resolveNeedName(need) {
-	if (typeof need === "string") return need;
-	if ("name" in need) return need.name;
-	if ("group" in need) return `__group:${need.group}`;
-	return need.name;
-}
-/**
-* Run one local step honoring the run-level {@link CheckMode}, reusing the
-* `runIdempotentStep` primitive for checked steps (never hand-rolled branching).
-* Mirrors the agent step loop's check phase so `kici run local --check` and a
-* remote check run produce identical per-step outcomes.
-*/
-async function runLocalStepWithCheckMode(step, ctx, checkMode) {
-	if (!step.check) {
-		if (checkMode !== CheckMode.enum.apply) return {
-			checkOutcome: CheckStepOutcome.enum.no_check,
-			status: "skipped",
-			outputs: void 0
-		};
-		return {
-			status: "success",
-			outputs: await step.run(ctx)
-		};
-	}
-	const res = await runIdempotentStep({
-		name: step.name,
-		check: () => step.check(ctx),
-		summarize: step.summarize,
-		apply: (drift) => step.run(ctx, drift),
-		whenInSync: step.whenInSync ? () => step.whenInSync(ctx) : void 0
-	}, {
-		dryRun: checkMode !== CheckMode.enum.apply,
-		yes: true,
-		log: (line) => ctx.log.info(line)
-	});
-	const driftSummary = res.drift != null ? step.summarize(res.drift) : void 0;
-	const status = res.outcome === CheckStepOutcome.enum.applied ? "success" : "skipped";
-	const mappedStatus = res.outcome === CheckStepOutcome.enum["dry-run"] ? "success" : status;
-	return {
-		checkOutcome: res.outcome,
-		status: mappedStatus,
-		outputs: res.result,
-		...driftSummary !== void 0 && { driftSummary }
-	};
-}
-/**
-* Run a local step through its retry policy. An attempt is one full
-* `runLocalStepWithCheckMode` call (which throws on failure). A thrown attempt
-* is retried while attempts remain AND `retryIf(err)` is true; backoff sleeps
-* between attempts. Mirrors the agent step loop so `kici run local` retries
-* identically to a remote run.
-*/
-async function runLocalStepWithRetry(step, ctx, checkMode, log) {
-	const retry = step.retry;
-	const max = retry?.maxAttempts ?? 1;
-	let lastErr;
-	for (let n = 1; n <= max; n++) try {
-		return await runLocalStepWithCheckMode(step, ctx, checkMode);
-	} catch (err) {
-		lastErr = err;
-		if (!(n < max && (retry?.retryIf?.(err) ?? true))) break;
-		const delay = computeBackoffDelay(n, {
-			maxAttempts: max,
-			delayMs: retry.delayMs,
-			backoff: retry.backoff,
-			maxDelayMs: retry.maxDelayMs
-		});
-		log(`Step '${step.name}' attempt ${n}/${max} failed: ${err instanceof Error ? err.message : String(err)}; retrying in ${delay}ms`);
-		await new Promise((r) => setTimeout(r, delay));
-	}
-	throw lastErr;
-}
-/**
-* Maintain the base-name `{ byMatrix, merged }` envelope as each matrix child
-* completes. `merged` is rebuilt last-write-wins in suffix order so the result
-* is deterministic regardless of child completion order — matching the remote
-* path's name-ordered merge.
-*/
-function updateBaseMatrixEnvelope(jobOutputsMap, baseName, matrixValues, childOutputs) {
-	const existing = jobOutputsMap.get(baseName);
-	const byMatrix = existing && "byMatrix" in existing ? { ...existing.byMatrix } : {};
-	const suffix = formatMatrixSuffix(matrixValues);
-	byMatrix[suffix] = childOutputs;
-	let merged = {};
-	for (const key of Object.keys(byMatrix).sort()) merged = {
-		...merged,
-		...byMatrix[key]
-	};
-	jobOutputsMap.set(baseName, {
-		byMatrix,
-		merged
-	});
-}
-/**
-* Resolve all jobs in a workflow, expanding matrix jobs and evaluating dynamic jobs.
-*
-* - Static jobs: create ResolvedJob with name, needs, job reference
-* - Matrix jobs: use expandMatrix() from SDK, create one ResolvedJob per combination
-* - Dynamic job functions: evaluate the function, recursively resolve results
-* - Fan-in: if a job needs a matrix-expanded job, it needs ALL instances
-*/
-async function resolveJobs(workflow, event) {
-	const resolved = [];
-	const expansionMap = /* @__PURE__ */ new Map();
-	for (const jobOrFn of workflow.jobs) if (isDynamicJobFn(jobOrFn)) {
-		const generatedJobs = await jobOrFn({
-			$: (await import("zx")).$,
-			ctx: {
-				workflow: { name: workflow.name },
-				event: toEventPayload(event)
-			},
-			log: {
-				info: () => {},
-				warn: () => {},
-				error: () => {},
-				debug: () => {}
-			},
-			env: { ...process.env },
-			kici: {
-				infrastructure: { list: () => Promise.resolve({
-					scalers: [],
-					agents: []
-				}) },
-				inventory: {
-					query: () => Promise.resolve([]),
-					get: () => Promise.resolve(null)
-				},
-				oidc: { token: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.oidc.token() is not available during local execution")) },
-				host: { requestReboot: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.host.requestReboot() is not available during local execution")) },
-				bootstrap: {
-					ensureInitRunner: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.bootstrap.ensureInitRunner() is not available during local execution")),
-					preBootSend: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.bootstrap.preBootSend() is not available during local execution"))
-				}
-			}
-		});
-		for (const genJob of generatedJobs) {
-			const genResolved = await resolveStaticJob(genJob, expansionMap);
-			resolved.push(...genResolved);
-		}
-	} else {
-		const jobResolved = await resolveStaticJob(jobOrFn, expansionMap);
-		resolved.push(...jobResolved);
-	}
-	for (const r of resolved) r.resolvedNeeds = resolveNeedsWithExpansion(r.job, expansionMap);
-	return resolved;
-}
-/**
-* Resolve a single static job, potentially expanding its matrix.
-*/
-async function resolveStaticJob(job, expansionMap) {
-	if (!job.matrix) {
-		expansionMap.set(job.name, [job.name]);
-		return [{
-			job,
-			expandedName: job.name,
-			matrixValues: {},
-			resolvedNeeds: []
-		}];
-	}
-	let staticMatrix;
-	if (typeof job.matrix === "function") {
-		const matrixContext = {
-			$: (await import("zx")).$,
-			ctx: {
-				workflow: { name: "" },
-				job: {
-					name: job.name,
-					runsOn: localRunsOnString(job.runsOn)
-				}
-			},
-			log: {
-				info: () => {},
-				warn: () => {},
-				error: () => {},
-				debug: () => {}
-			},
-			env: { ...process.env }
-		};
-		staticMatrix = await job.matrix(matrixContext);
-	} else staticMatrix = job.matrix;
-	let expanded = expandMatrix(staticMatrix);
-	if (job.include || job.exclude) expanded = applyIncludeExclude(expanded, job.include, job.exclude);
-	const expandedNames = [];
-	const results = [];
-	for (const matrixValues of expanded) {
-		const suffix = formatMatrixSuffix(matrixValues);
-		const expandedName = `${job.name} (${suffix})`;
-		expandedNames.push(expandedName);
-		results.push({
-			job,
-			expandedName,
-			matrixValues,
-			resolvedNeeds: []
-		});
-	}
-	expansionMap.set(job.name, expandedNames);
-	return results;
-}
-/**
-* Resolve needs with matrix expansion awareness.
-* If a job needs a matrix-expanded job, it needs ALL expanded instances (fan-in).
-*/
-function resolveNeedsWithExpansion(job, expansionMap) {
-	if (!job.needs || job.needs.length === 0) return [];
-	const resolvedNeeds = [];
-	for (const need of job.needs) {
-		const needName = resolveNeedName(need);
-		const expandedNames = expansionMap.get(needName);
-		if (expandedNames) resolvedNeeds.push(...expandedNames);
-		else resolvedNeeds.push(needName);
-	}
-	return resolvedNeeds;
-}
-/**
-* Execute a single resolved job: evaluate rules, run steps sequentially,
-* check abort signal between steps, collect outputs.
-*/
-async function executeResolvedJob(resolvedJob, context) {
-	const { expandedName, matrixValues } = resolvedJob;
-	const startTime = Date.now();
-	const hasMatrix = Object.keys(matrixValues).length > 0;
-	try {
-		return await executeResolvedJobInner(resolvedJob, context, startTime);
-	} catch (e) {
-		const durationMs = Date.now() - startTime;
-		const error = e instanceof Error ? e : new Error(String(e));
-		formatter.logJobFailure(expandedName, durationMs, error);
-		return {
-			name: expandedName,
-			status: "failure",
-			durationMs,
-			steps: [],
-			error,
-			matrixValues: hasMatrix ? matrixValues : void 0
-		};
-	}
-}
-async function executeResolvedJobInner(resolvedJob, context, startTime) {
-	const { job, expandedName, matrixValues } = resolvedJob;
-	formatter.logJobStart(expandedName);
-	const sdkSetters = await resolveSdkSetters(context.kiciDir);
-	let ruleResults;
-	if (job.rules && job.rules.length > 0) {
-		const ruleContext = createRuleContext(context.event, context.event.changedFiles, context.dispatchInputs ?? {});
-		const ruleEval = await evaluateRulesWithFormatting(job.rules, ruleContext, expandedName);
-		ruleResults = ruleEval.results;
-		if (!ruleEval.allPassed) return {
-			name: expandedName,
-			status: "skipped",
-			durationMs: Date.now() - startTime,
-			steps: [],
-			ruleResults,
-			matrixValues: Object.keys(matrixValues).length > 0 ? matrixValues : void 0
-		};
-	}
-	const outputsMap = /* @__PURE__ */ new Map();
-	const refMap = /* @__PURE__ */ new WeakMap();
-	sdkSetters.setStepOutputsMap(outputsMap);
-	sdkSetters.setStepRefMap(refMap);
-	setStepOutputsMap(outputsMap);
-	setStepRefMap(refMap);
-	sdkSetters.setJobOutputsMap(context.jobOutputsMap);
-	setJobOutputsMap(context.jobOutputsMap);
-	const hasMatrix = Object.keys(matrixValues).length > 0;
-	const repoRoot = context.execDir;
-	const stepCtx = createStepContext({ name: context.workflowName }, {
-		name: expandedName,
-		runsOn: localRunsOnString(job.runsOn)
-	}, repoRoot, void 0, hasMatrix ? matrixValues : void 0, context.secrets, void 0, context.event.payload, context.event.provider, context.dispatchInputs ?? {}, context.signal);
-	const stepResults = [];
-	let stepCounter = 0;
-	for (const stepOrFn of flattenStepInputs(job.steps)) {
-		if (context.signal.aborted) return {
-			name: expandedName,
-			status: "cancelled",
-			durationMs: Date.now() - startTime,
-			steps: stepResults,
-			ruleResults,
-			matrixValues: hasMatrix ? matrixValues : void 0,
-			cancelled: true
-		};
-		let normalizedStep;
-		if (typeof stepOrFn === "function") {
-			stepCounter++;
-			const name = `step-${stepCounter}`;
-			refMap.set(stepOrFn, name);
-			normalizedStep = {
-				_tag: "Step",
-				name,
-				run: stepOrFn
-			};
-		} else {
-			normalizedStep = stepOrFn;
-			if (!normalizedStep.name) stepCounter++;
-		}
-		formatter.logStepStart(expandedName, normalizedStep.name);
-		const stepStart = Date.now();
-		try {
-			const checkMode = context.checkMode ?? CheckMode.enum.apply;
-			const phase = await runLocalStepWithRetry(normalizedStep, stepCtx, checkMode, (line) => formatter.logJobLine(expandedName, line));
-			const outputs = phase.outputs;
-			const stepDuration = Date.now() - stepStart;
-			formatter.logStepComplete(expandedName, normalizedStep.name, stepDuration);
-			const stepResult = {
-				name: normalizedStep.name,
-				status: phase.status,
-				durationMs: stepDuration,
-				outputs,
-				...phase.checkOutcome !== void 0 && { checkOutcome: phase.checkOutcome },
-				...phase.driftSummary !== void 0 && { driftSummary: phase.driftSummary }
-			};
-			if (outputs != null) outputsMap.set(normalizedStep.name, outputs);
-			stepResults.push(stepResult);
-		} catch (e) {
-			const stepDuration = Date.now() - stepStart;
-			const error = e instanceof Error ? e : new Error(String(e));
-			formatter.logStepError(expandedName, normalizedStep.name, error);
-			stepResults.push({
-				name: normalizedStep.name,
-				status: "failure",
-				durationMs: stepDuration,
-				error
-			});
-			const durationMs = Date.now() - startTime;
-			formatter.logJobFailure(expandedName, durationMs, error);
-			return {
-				name: expandedName,
-				status: "failure",
-				durationMs,
-				steps: stepResults,
-				ruleResults,
-				matrixValues: hasMatrix ? matrixValues : void 0,
-				error
-			};
-		}
-	}
-	const stepsWithOutputs = stepResults.filter((s) => s.outputs != null);
-	let jobOutputs;
-	if (stepsWithOutputs.length === 1 && stepResults.length === 1) jobOutputs = stepsWithOutputs[0].outputs;
-	else if (stepsWithOutputs.length > 0) {
-		const aggregated = {};
-		for (const stepResult of stepsWithOutputs) aggregated[stepResult.name] = stepResult.outputs;
-		jobOutputs = aggregated;
-	}
-	if (jobOutputs) {
-		context.jobOutputsMap.set(expandedName, jobOutputs);
-		if (expandedName !== job.name) updateBaseMatrixEnvelope(context.jobOutputsMap, job.name, matrixValues, jobOutputs);
-	}
-	const durationMs = Date.now() - startTime;
-	formatter.logJobComplete(expandedName, durationMs);
-	return {
-		name: expandedName,
-		status: "success",
-		durationMs,
-		steps: stepResults,
-		ruleResults,
-		matrixValues: hasMatrix ? matrixValues : void 0
-	};
-}
-//#endregion
-export { executeResolvedJob, resolveJobs };
-
-//# sourceMappingURL=job-runner.js.map

package/dist/local-executor/materializer.js

@@ -1,132 +0,0 @@
-import "../rolldown-runtime-ClRpJifh.js";
-import { selectOverlayFiles } from "../remote/uploader.js";
-import path from "node:path";
-import fs from "node:fs/promises";
-import { logger } from "@kici-dev/core";
-import { execSync } from "node:child_process";
-import os from "node:os";
-import { randomBytes } from "node:crypto";
-import { gcStaleTmpDirs } from "@kici-dev/core/tmp-gc";
-//#region src/local-executor/materializer.ts
-/**
-* Materialize an isolated tmp checkout of the repo for `kici run local`.
-*
-* Reproduces the same workspace `kici run remote` reconstructs on the agent:
-* a clone checked out at HEAD, with the local overlay (dirty + untracked,
-* minus gitignored, with `.kiciignore` applied) copied on top and local
-* deletions removed. Steps then execute against this copy so the developer's
-* real working tree is never mutated.
-*
-* Secrets are NOT part of the overlay: gitignored files such as
-* `.kici/.env.local` are excluded by the shared selection, so the tmp checkout
-* never receives them — the run reads them from the original `.kici/`.
-*/
-/** Max number of overlay files copied concurrently. */
-const COPY_BATCH_SIZE = 32;
-/**
-* Materialize the repo at `repoRoot` into an isolated tmp checkout.
-*
-* @param repoRoot - Path to the git repository root
-* @param opts - Optional configuration (tmp base directory)
-* @returns The tmp checkout path and a cleanup callback
-* @throws If `repoRoot` is not inside a git work tree
-*/
-async function materializeCheckout(repoRoot, opts) {
-	requireGitRepo(repoRoot);
-	const base = opts?.runDir ?? os.tmpdir();
-	await fs.mkdir(base, { recursive: true });
-	const tmpDir = path.join(base, `kici-run-${randomBytes(3).toString("hex")}`);
-	const { sha, existingFiles, deletedFiles } = await selectOverlayFiles(repoRoot);
-	execSync(`git clone --no-hardlinks --quiet ${shellQuote(repoRoot)} ${shellQuote(tmpDir)}`, { stdio: "ignore" });
-	execSync(`git checkout --quiet ${sha}`, {
-		cwd: tmpDir,
-		stdio: "ignore"
-	});
-	await applyOverlay(repoRoot, tmpDir, existingFiles, deletedFiles);
-	return {
-		path: tmpDir,
-		cleanup: async () => {
-			await fs.rm(tmpDir, {
-				recursive: true,
-				force: true
-			});
-		}
-	};
-}
-/**
-* Checkouts retained for inspection (failed runs, --keep) stay around this
-* long before the next `kici run local` invocation collects them.
-*/
-const RUN_CHECKOUT_GC_MAX_AGE_MS = 4320 * 60 * 1e3;
-/** Matches the kici-run-<6 hex> dirs materializeCheckout creates — nothing else. */
-const RUN_CHECKOUT_PATTERN = /^kici-run-[0-9a-f]{6}$/;
-/**
-* Collect stale retained checkouts under the run base. Invoked on every
-* `kici run local`; never throws (the GC must not break the run).
-*/
-async function gcStaleRunCheckouts(base) {
-	return gcStaleTmpDirs({
-		base,
-		pattern: RUN_CHECKOUT_PATTERN,
-		maxAgeMs: RUN_CHECKOUT_GC_MAX_AGE_MS,
-		log: (m) => logger.debug(m)
-	});
-}
-/**
-* Throw an actionable error if `repoRoot` is not a git work tree.
-*/
-function requireGitRepo(repoRoot) {
-	try {
-		execSync("git rev-parse --is-inside-work-tree", {
-			cwd: repoRoot,
-			stdio: "ignore"
-		});
-	} catch {
-		throw new Error(`kici run local needs a git repository to build an isolated checkout, but "${repoRoot}" is not inside a git work tree. Initialize a repo, or re-run with --in-place to execute against the working directory directly.`);
-	}
-}
-/**
-* Copy the overlay files onto the clone and remove local deletions.
-*/
-async function applyOverlay(repoRoot, tmpDir, existingFiles, deletedFiles) {
-	for (let i = 0; i < existingFiles.length; i += COPY_BATCH_SIZE) {
-		const batch = existingFiles.slice(i, i + COPY_BATCH_SIZE);
-		await Promise.all(batch.map((file) => copyOverlayFile(repoRoot, tmpDir, file)));
-	}
-	for (let i = 0; i < deletedFiles.length; i += COPY_BATCH_SIZE) {
-		const batch = deletedFiles.slice(i, i + COPY_BATCH_SIZE);
-		await Promise.all(batch.map((file) => fs.rm(path.join(tmpDir, file), { force: true })));
-	}
-}
-/**
-* Copy a single overlay file, preserving its mode (e.g. the exec bit).
-*
-* Symlinks are recreated as links rather than dereferenced — the same shape the
-* remote path's tarball preserves. Following them would copy the link target's
-* content (and a directory symlink such as `node_modules/@scope/pkg` would
-* throw `EISDIR`), losing the link identity the workspace relies on.
-*/
-async function copyOverlayFile(repoRoot, tmpDir, file) {
-	const src = path.join(repoRoot, file);
-	const dest = path.join(tmpDir, file);
-	await fs.mkdir(path.dirname(dest), { recursive: true });
-	const srcStat = await fs.lstat(src);
-	if (srcStat.isSymbolicLink()) {
-		const target = await fs.readlink(src);
-		await fs.rm(dest, { force: true });
-		await fs.symlink(target, dest);
-		return;
-	}
-	await fs.copyFile(src, dest);
-	await fs.chmod(dest, srcStat.mode);
-}
-/**
-* Minimal single-quote shell escaping for paths passed to git via execSync.
-*/
-function shellQuote(value) {
-	return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-//#endregion
-export { gcStaleRunCheckouts, materializeCheckout };
-
-//# sourceMappingURL=materializer.js.map