@kici-dev/compiler 0.1.21 → 0.1.23

package/dist/commands/run.js

@@ -9,11 +9,19 @@ import { createOverlayTarball, getSizeWarning, uploadTarball } from "../remote/u
 import { formatJsonResult } from "../remote/output/json.js";
 import { formatJunitResult } from "../remote/output/junit.js";
 import { formatErrorHighlight, formatMultiFixtureSummary, formatSummary } from "../remote/output/summary.js";
+import { compileCommand } from "./compile.js";
 import { compileFixtures, filterFixtures } from "../fixtures/compiler.js";
+import { describeEvent } from "../fixtures/describe-event.js";
+import { FixturePickerCancelledError, runFixturePicker } from "../fixtures/picker.js";
+import { listHeldRunsForRun, resolveHeldRunContext } from "./held-run-client.js";
+import { handleNewHolds } from "./run-hold-watch.js";
 import path from "node:path";
 import pc from "picocolors";
 import { readFile, writeFile } from "node:fs/promises";
 import { formatBytes, logger, toErrorMessage } from "@kici-dev/core";
+import { coerceDispatchInputs, parseInputPairs } from "@kici-dev/engine";
+import { normalizeRunsOnToMatchers } from "@kici-dev/engine/labels/compile";
+import { confirm } from "@inquirer/prompts";
 //#region src/commands/run.ts
 /** Terminal run statuses returned by the Platform run-status snapshot. */
 const TERMINAL_STATUSES = new Set([
@@ -22,9 +30,81 @@ const TERMINAL_STATUSES = new Set([
 	"cancelled",
 	"error"
 ]);
+/**
+* Compile `--target` selector strings into a {@link HostTargetSelector}. Each
+* string becomes one AND value (its own include set); repeated values
+* AND-combine. Returns undefined when no `--target` is given. Throws when
+* `--target-allow-empty` is set without at least one `--target`.
+*/
+function buildTargetSelector(targets, allowEmpty) {
+	if (!targets || targets.length === 0) {
+		if (allowEmpty) throw new Error("--target-allow-empty requires at least one --target selector");
+		return;
+	}
+	return {
+		values: targets.map((t) => normalizeRunsOnToMatchers(t, "kici run --target")),
+		allowEmpty
+	};
+}
+/**
+* Look up the dispatch-trigger `inputs` descriptor for a workflow from a parsed
+* inline lock file. When `workflowName` is given, only that workflow's dispatch
+* triggers are considered; otherwise descriptors across all workflows are merged
+* (best-effort fast-fail — the orchestrator re-validates against the matched
+* workflow authoritatively). Returns undefined when no dispatch inputs declared.
+*/
+function lookupDispatchInputsDescriptor(inlineLockFile, workflowName) {
+	if (!inlineLockFile) return void 0;
+	let lock;
+	try {
+		lock = JSON.parse(inlineLockFile);
+	} catch {
+		return;
+	}
+	const merged = {};
+	let found = false;
+	for (const wf of lock.workflows ?? []) {
+		if (workflowName && wf.name !== workflowName) continue;
+		for (const trigger of wf.triggers ?? []) if (trigger._type === "dispatch" && trigger.inputs) {
+			Object.assign(merged, trigger.inputs);
+			found = true;
+		}
+	}
+	return found ? merged : void 0;
+}
+/**
+* Validate raw `--input KEY=VALUE` pairs against the (optional) lock descriptor
+* and return the raw operator pairs verbatim. The CLI fast-fails on malformed /
+* invalid input for UX, but forwards the **raw** strings — the orchestrator is
+* authoritative and applies coercion + defaults exactly once.
+*/
+function buildDispatchInputs(pairs, descriptor) {
+	if (!pairs.length) return {};
+	const raw = parseInputPairs(pairs);
+	if (descriptor) {
+		const r = coerceDispatchInputs(raw, descriptor);
+		if ("error" in r) throw r.error;
+	}
+	return raw;
+}
 /** Interval between status/log polls while a run is active. */
 const POLL_INTERVAL_MS = 750;
 /**
+* Recompile `.kici/workflows` → `kici.lock.json` before a remote run, mirroring
+* `kici run local`. The orchestrator matches triggers and dispatches against the
+* inline lock, so a stale lock would route an edited or newly-added workflow
+* incorrectly. Returns false on a compile/validation error so the caller can
+* abort before any upload or dispatch.
+*/
+async function compileBeforeRemoteRun(options) {
+	return compileCommand({
+		kiciDir: options.kiciDir ?? ".kici",
+		check: false,
+		verbose: options.debug ?? false,
+		quiet: Boolean(options.json || options.quiet)
+	});
+}
+/**
 * Run a workflow locally using the local executor.
 * Thin wrapper that delegates to executeLocal from local-executor.
 *
@@ -58,6 +138,7 @@ async function runRemoteCommand(fixture, options) {
 		if (!options.quiet) logger.info(pc.gray("Debug mode enabled"));
 	}
 	try {
+		buildTargetSelector(options.targets, options.targetAllowEmpty ?? false);
 		if (options.workflow && !fixture && !options.all) return await runDirectWorkflow(options.workflow, options);
 		const kiciDir = resolveKiciDir(options.kiciDir);
 		if (options.history) {
@@ -68,9 +149,20 @@ async function runRemoteCommand(fixture, options) {
 			return true;
 		}
 		const fixtures = await compileFixtures(path.join(kiciDir, "tests"));
-		if (!fixture && !options.all) return listFixtures(fixtures);
 		let selected;
-		if (options.all) selected = fixtures;
+		if (options.pick) {
+			if (fixtures.length === 0) return listFixtures(fixtures);
+			try {
+				selected = await runFixturePicker(fixtures);
+			} catch (err) {
+				if (err instanceof FixturePickerCancelledError) {
+					logger.info(pc.gray(err.message));
+					return false;
+				}
+				throw err;
+			}
+		} else if (!fixture && !options.all) return listFixtures(fixtures);
+		else if (options.all) selected = fixtures;
 		else selected = filterFixtures(fixtures, fixture);
 		if (selected.length === 0) {
 			logger.info(pc.yellow(`No fixtures matched: ${fixture ?? "(none)"}`));
@@ -111,17 +203,6 @@ function listFixtures(fixtures) {
 	return true;
 }
 /**
-* Describe the event type from a fixture's trigger config.
-*/
-function describeEvent(event) {
-	if (!event || typeof event !== "object") return "unknown";
-	const e = event;
-	if (e._type === "push") return "push";
-	if (e._type === "pr") return `pr:${e.action ?? "open"}`;
-	if (typeof e._type === "string") return String(e._type);
-	return "custom";
-}
-/**
 * Resolve the authenticated Platform client and the run target (org + cluster).
 *
 * Org resolution: `--org` → `config.activeOrgId` → error.
@@ -161,6 +242,7 @@ function resolvePlatformContext(config, options) {
 * Run fixtures remotely against the Platform.
 */
 async function runFixturesRemotely(fixtures, options) {
+	if (!await compileBeforeRemoteRun(options)) return false;
 	const config = await loadGlobalConfig();
 	const ctx = resolvePlatformContext(config, options);
 	if (!ctx) return false;
@@ -295,7 +377,16 @@ async function runSingleFixture(fixture, ctx, options, config, history) {
 			workflowName: opts.workflowName,
 			inlineLockFile: overlay.inlineLockFile,
 			fullRepo: true,
-			...options.checkMode && { checkMode: options.checkMode }
+			...options.checkMode && { checkMode: options.checkMode },
+			...(() => {
+				const target = buildTargetSelector(options.targets, options.targetAllowEmpty ?? false);
+				return target ? { target } : {};
+			})(),
+			...(() => {
+				const descriptor = lookupDispatchInputsDescriptor(overlay.inlineLockFile, opts.workflowName);
+				const dispatchInputs = buildDispatchInputs(options.inputs ?? [], descriptor);
+				return Object.keys(dispatchInputs).length ? { dispatchInputs } : {};
+			})()
 		});
 		if (triggerResult.status === "rejected") {
 			if (!options.quiet) logger.info(pc.red(`Rejected: ${triggerResult.reason ?? "unknown reason"}`));
@@ -372,6 +463,8 @@ async function pollRunToCompletion(ctx, runId, fixtureId, options) {
 	process.on("SIGINT", cancelHandler);
 	try {
 		let lastStatus = null;
+		const seenHolds = /* @__PURE__ */ new Set();
+		let heldCtx;
 		while (!cancelled) {
 			const logs = await ctx.client.runLogs(ctx.orgId, runId, cursor, ctx.target);
 			for (const line of logs.lines) {
@@ -381,7 +474,9 @@ async function pollRunToCompletion(ctx, runId, fixtureId, options) {
 			}
 			cursor = logs.nextCursor;
 			lastStatus = await ctx.client.runStatus(ctx.orgId, runId, ctx.target);
-			if ((lastStatus.done || TERMINAL_STATUSES.has(lastStatus.status)) && logs.done) return finishRun(fixtureId, runId, lastStatus, startTime, tailLines, options);
+			const terminal = lastStatus.done || TERMINAL_STATUSES.has(lastStatus.status);
+			if (terminal && logs.done) return finishRun(fixtureId, runId, lastStatus, startTime, tailLines, options);
+			if (!terminal && !options.quiet) await watchRunHolds(runId, seenHolds, () => heldCtx, (c) => heldCtx = c, options);
 			await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
 		}
 		return {
@@ -395,6 +490,34 @@ async function pollRunToCompletion(ctx, runId, fixtureId, options) {
 		process.removeListener("SIGINT", cancelHandler);
 	}
 }
+/**
+* Fetch this run's pending holds and surface them to the operator. The held-run
+* context is resolved lazily (cached across ticks via the getter/setter). A
+* resolution / fetch failure is swallowed — hold-visibility is best-effort and
+* must never abort the run watch.
+*/
+async function watchRunHolds(runId, seenHolds, getCtx, setCtx, options) {
+	try {
+		let ctx = getCtx();
+		if (ctx === void 0) {
+			ctx = await resolveHeldRunContext();
+			setCtx(ctx);
+		}
+		if (!ctx) return;
+		const holds = await listHeldRunsForRun(ctx, runId);
+		if (holds.length === 0) return;
+		await handleNewHolds({
+			holds,
+			seen: seenHolds,
+			isTty: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+			approveAll: Boolean(options.approveAll),
+			confirm: (message) => confirm({
+				message,
+				default: false
+			})
+		});
+	} catch {}
+}
 /** Build the final result + render the summary table for a completed run. */
 function finishRun(fixtureId, runId, status, startTime, tailLines, options) {
 	const durationMs = Date.now() - startTime;
@@ -456,6 +579,7 @@ function buildEventFromFixture(opts) {
 * Platform.
 */
 async function runDirectWorkflow(workflowName, options) {
+	if (!await compileBeforeRemoteRun(options)) return false;
 	const ctx = resolvePlatformContext(await loadGlobalConfig(), options);
 	if (!ctx) return false;
 	if (options.json) options.quiet = true;
@@ -483,7 +607,16 @@ async function runDirectWorkflow(workflowName, options) {
 			workflowName,
 			inlineLockFile: overlay.inlineLockFile,
 			fullRepo: true,
-			...options.checkMode && { checkMode: options.checkMode }
+			...options.checkMode && { checkMode: options.checkMode },
+			...(() => {
+				const target = buildTargetSelector(options.targets, options.targetAllowEmpty ?? false);
+				return target ? { target } : {};
+			})(),
+			...(() => {
+				const descriptor = lookupDispatchInputsDescriptor(overlay.inlineLockFile, workflowName);
+				const dispatchInputs = buildDispatchInputs(options.inputs ?? [], descriptor);
+				return Object.keys(dispatchInputs).length ? { dispatchInputs } : {};
+			})()
 		});
 		if (!options.quiet) logger.info(pc.green(`Run started: ${triggerResult.runId}`));
 		if (options.wait === false) return triggerResult.status === "accepted";
@@ -511,6 +644,6 @@ function displayRemoteResults(results) {
 	logger.info("");
 }
 //#endregion
-export { runLocalCommand, runRemoteCommand };
+export { buildDispatchInputs, buildTargetSelector, lookupDispatchInputsDescriptor, runLocalCommand, runRemoteCommand };
 
 //# sourceMappingURL=run.js.map

package/dist/commands/test.d.ts

@@ -19,6 +19,8 @@ export interface TestOptions extends PayloadOptions {
 export interface RemoteRunOptions extends TestOptions {
     /** Run all available fixtures */
     all?: boolean;
+    /** Interactively pick fixtures to run (multi-select checkbox). */
+    pick?: boolean;
     /** Run matching fixtures concurrently */
     parallel?: boolean;
     /** Fire and forget (print runIds, don't stream) */
@@ -45,6 +47,18 @@ export interface RemoteRunOptions extends TestOptions {
      * Defaults to `apply`.
      */
     checkMode?: CheckMode;
+    /** `--target <selector>` values (repeatable), AND-combined into host narrowing. */
+    targets?: string[];
+    /** `--target-allow-empty`: a target that zeroes a runsOnAll job skips it instead of failing. */
+    targetAllowEmpty?: boolean;
+    /**
+     * `--approve-all` (alias `--yes`): auto-approve every approval gate this run
+     * holds on (run-scoped only — the run id this invocation dispatched). The
+     * operator must still be clause-eligible per hold; an ineligible hold blocks.
+     */
+    approveAll?: boolean;
+    /** `--input KEY=VALUE` values (repeatable): typed workflow-dispatch inputs. */
+    inputs?: string[];
 }
 /** Result of a single remote fixture run */
 export interface RemoteRunResult {

package/dist/commands/types.d.ts

@@ -1,6 +1,8 @@
 export interface TypesOptions {
     /** Path to .kici directory (defaults to .kici) */
     kiciDir?: string;
+    /** Suppress the success line on stdout (so machine-readable output stays pure). */
+    quiet?: boolean;
 }
 /**
  * Generate TypeScript declarations for environment secrets.

package/dist/commands/types.js

@@ -33,7 +33,7 @@ async function typesCommand(options = {}) {
 		await fs.mkdir(typesDir, { recursive: true });
 		const outputPath = path.join(typesDir, "secrets.d.ts");
 		await fs.writeFile(outputPath, dtsContent, "utf-8");
-		console.log(pc.green("Types generated") + pc.dim(` ${outputPath}`));
+		if (!options.quiet) console.log(pc.green("Types generated") + pc.dim(` ${outputPath}`));
 		return true;
 	} catch (err) {
 		if (err instanceof DashboardClientError) {

package/dist/fixtures/describe-event.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Describe the event type from a fixture's trigger config, for the fixtures
+ * table and the interactive picker.
+ */
+export declare function describeEvent(event: unknown): string;
+//# sourceMappingURL=describe-event.d.ts.map

package/dist/fixtures/describe-event.js

@@ -0,0 +1,18 @@
+import "../chunk-BTugEXQM.js";
+//#region src/fixtures/describe-event.ts
+/**
+* Describe the event type from a fixture's trigger config, for the fixtures
+* table and the interactive picker.
+*/
+function describeEvent(event) {
+	if (!event || typeof event !== "object") return "unknown";
+	const e = event;
+	if (e._type === "push") return "push";
+	if (e._type === "pr") return `pr:${e.action ?? "open"}`;
+	if (typeof e._type === "string") return String(e._type);
+	return "custom";
+}
+//#endregion
+export { describeEvent };
+
+//# sourceMappingURL=describe-event.js.map

package/dist/fixtures/picker.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Interactive multi-select fixture picker for `kici run remote --pick`.
+ *
+ * Lists every available fixture with its source and event type, lets the user
+ * toggle one or more via a checkbox prompt, and returns the chosen fixtures.
+ * The caller feeds them into the standard remote-dispatch pipeline, so a picked
+ * run is identical to one selected by name / glob / --all.
+ */
+import type { CompiledFixture } from './compiler.js';
+export declare class FixturePickerCancelledError extends Error {
+    constructor(message: string);
+}
+/**
+ * Run the interactive multi-select fixture picker.
+ *
+ * @throws FixturePickerCancelledError when stdin is not a TTY or the user aborts.
+ */
+export declare function runFixturePicker(fixtures: CompiledFixture[]): Promise<CompiledFixture[]>;
+//# sourceMappingURL=picker.d.ts.map

package/dist/fixtures/picker.js

@@ -0,0 +1,64 @@
+import "../chunk-BTugEXQM.js";
+import { describeEvent } from "./describe-event.js";
+import path from "node:path";
+import pc from "picocolors";
+import { logger } from "@kici-dev/core";
+import { checkbox } from "@inquirer/prompts";
+//#region src/fixtures/picker.ts
+/**
+* Interactive multi-select fixture picker for `kici run remote --pick`.
+*
+* Lists every available fixture with its source and event type, lets the user
+* toggle one or more via a checkbox prompt, and returns the chosen fixtures.
+* The caller feeds them into the standard remote-dispatch pipeline, so a picked
+* run is identical to one selected by name / glob / --all.
+*/
+var FixturePickerCancelledError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "FixturePickerCancelledError";
+	}
+};
+function isStdinTty() {
+	return Boolean(process.stdin.isTTY);
+}
+/** Build a single fixture's display row: `id  <source>  <event type>`. */
+function fixtureRow(f) {
+	const opts = typeof f.fixture.options === "function" ? null : f.fixture.options;
+	const eventType = opts?.event ? describeEvent(opts.event) : "(async)";
+	const source = path.relative(process.cwd(), f.sourceFile);
+	return `${f.id}  ${pc.gray(source)}  ${eventType}`;
+}
+function printFixtureList(fixtures) {
+	logger.info(pc.bold("Available fixtures:"));
+	for (const f of fixtures) logger.info(`  ${pc.cyan(f.id)} — ${fixtureRow(f)}`);
+}
+/**
+* Run the interactive multi-select fixture picker.
+*
+* @throws FixturePickerCancelledError when stdin is not a TTY or the user aborts.
+*/
+async function runFixturePicker(fixtures) {
+	if (!isStdinTty()) {
+		printFixtureList(fixtures);
+		throw new FixturePickerCancelledError("--pick requires an interactive terminal. Pass a fixture name instead.");
+	}
+	let chosenIds;
+	try {
+		chosenIds = await checkbox({
+			message: "Select fixtures to run",
+			choices: fixtures.map((f) => ({
+				name: fixtureRow(f),
+				value: f.id
+			})),
+			required: true
+		});
+	} catch (err) {
+		throw new FixturePickerCancelledError(`Picker cancelled: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	return fixtures.filter((f) => chosenIds.includes(f.id));
+}
+//#endregion
+export { FixturePickerCancelledError, runFixturePicker };
+
+//# sourceMappingURL=picker.js.map