@kici-dev/compiler 0.0.0 → 0.1.2

package/dist/commands/run.js

@@ -0,0 +1,562 @@
+import "../chunk-gOLHoazu.js";
+import { resolveKiciDir } from "../execution/executor.js";
+import "../execution/index.js";
+import { loadGlobalConfig } from "../remote/config.js";
+import { AuthenticationError, ConnectionError, OrchestratorClient } from "../remote/client.js";
+import { compileFixtures, filterFixtures } from "../fixtures/compiler.js";
+import { createOverlayTarball, getSizeWarning, uploadTarball } from "../remote/uploader.js";
+import { ObserverClient } from "../remote/observer.js";
+import { StreamingFormatter } from "../remote/output/streaming.js";
+import { formatErrorHighlight, formatMultiFixtureSummary, formatSummary } from "../remote/output/summary.js";
+import { formatJsonResult } from "../remote/output/json.js";
+import { formatJunitResult } from "../remote/output/junit.js";
+import { RunHistory } from "../remote/history.js";
+import pc from "picocolors";
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { formatBytes, logger, toErrorMessage } from "@kici-dev/shared";
+//#region src/commands/run.ts
+/**
+* Run a workflow locally using the local executor.
+* Thin wrapper that delegates to executeLocal from local-executor.
+*
+* Exit codes: 0 = success, 1 = job failure, 2 = config/compilation error
+*/
+async function runLocalCommand(options) {
+	if (options.debug) {
+		process.env.KICI_DEBUG = "true";
+		if (!options.quiet) logger.info(pc.gray("Debug mode enabled"));
+	}
+	try {
+		const { executeLocal } = await import("../local-executor/index.js");
+		return await executeLocal(options);
+	} catch (error) {
+		if (error instanceof Error && (error.message.includes("Cannot find module") || error.message.includes("ERR_MODULE_NOT_FOUND"))) {
+			logger.error(pc.red("Local executor not yet available. The local execution engine is under development."));
+			return false;
+		}
+		const message = toErrorMessage(error);
+		logger.error(pc.red(`\nError: ${message}\n`));
+		if (options.debug && error instanceof Error && error.stack) logger.error(pc.gray(error.stack));
+		return false;
+	}
+}
+/**
+* Run fixtures remotely against the orchestrator.
+* Migrated from test.ts — full remote execution functionality.
+*/
+async function runRemoteCommand(fixture, options) {
+	if (options.debug) {
+		process.env.KICI_DEBUG = "true";
+		if (!options.quiet) logger.info(pc.gray("Debug mode enabled"));
+	}
+	try {
+		if (options.workflow && !fixture && !options.all) return await runDirectWorkflow(options.workflow, options);
+		const kiciDir = resolveKiciDir(options.kiciDir);
+		if (options.history) {
+			const history = new RunHistory();
+			await history.load();
+			const entries = history.getEntries({ limit: 20 });
+			console.log(history.formatTable(entries));
+			return true;
+		}
+		const fixtures = await compileFixtures(path.join(kiciDir, "tests"));
+		if (!fixture && !options.all) return listFixtures(fixtures);
+		let selected;
+		if (options.all) selected = fixtures;
+		else selected = filterFixtures(fixtures, fixture);
+		if (selected.length === 0) {
+			logger.info(pc.yellow(`No fixtures matched: ${fixture ?? "(none)"}`));
+			logger.info(pc.gray("Run `kici run remote` with no arguments to list available fixtures."));
+			return false;
+		}
+		return await runFixturesRemotely(selected, options);
+	} catch (error) {
+		const message = toErrorMessage(error);
+		logger.error(pc.red(`\nError: ${message}\n`));
+		if (options.debug && error instanceof Error && error.stack) logger.error(pc.gray(error.stack));
+		return false;
+	}
+}
+/**
+* List available fixtures as a table.
+*/
+function listFixtures(fixtures) {
+	if (fixtures.length === 0) {
+		logger.info(pc.yellow("No fixtures found."));
+		logger.info(pc.gray("Create fixture files in .kici/tests/ to get started."));
+		logger.info(pc.gray("Example: export const pushMain = fixture(\"push-main\", { event: push({ branches: [\"main\"] }) })"));
+		return true;
+	}
+	logger.info(pc.bold("\nAvailable fixtures:\n"));
+	const idWidth = Math.max(12, ...fixtures.map((f) => f.id.length)) + 2;
+	const header = `  ${pc.bold("ID".padEnd(idWidth))} ${pc.bold("Source".padEnd(40))} ${pc.bold("Event type")}`;
+	logger.info(header);
+	logger.info(`  ${"".padEnd(idWidth, "-")} ${"".padEnd(40, "-")} ${"".padEnd(15, "-")}`);
+	for (const f of fixtures) {
+		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);
+		logger.info(`  ${pc.cyan(f.id.padEnd(idWidth))} ${pc.gray(source.padEnd(40))} ${eventType}`);
+	}
+	logger.info(pc.gray(`\n  ${fixtures.length} fixture(s) available`));
+	logger.info(pc.gray("  Run: kici run remote <fixture-name> or kici run remote --all\n"));
+	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";
+}
+/**
+* Run fixtures remotely against the orchestrator.
+*/
+async function runFixturesRemotely(fixtures, options) {
+	const config = await loadGlobalConfig();
+	if (!config.token) {
+		logger.error(pc.red("Not authenticated. Run `kici login` to set up your API key."));
+		return false;
+	}
+	const endpoint = config.endpoint ?? config.platformEndpoint;
+	if (!endpoint) {
+		logger.error(pc.red("No orchestrator endpoint configured. Run `kici login --endpoint <url>` to set one."));
+		return false;
+	}
+	if (options.json) options.quiet = true;
+	const client = new OrchestratorClient({
+		endpoint,
+		token: config.token
+	});
+	const history = new RunHistory();
+	await history.load();
+	if (!options.quiet) {
+		logger.info(pc.gray(`Orchestrator: ${endpoint}`));
+		logger.info(pc.gray(`Fixtures: ${fixtures.length} to run\n`));
+	}
+	const results = [];
+	if (options.parallel && fixtures.length > 1) {
+		const promises = fixtures.map((f) => runSingleFixture(f, client, options, config, history));
+		const settled = await Promise.allSettled(promises);
+		for (const s of settled) if (s.status === "fulfilled") results.push(s.value);
+		else results.push({
+			fixtureId: "unknown",
+			runId: "",
+			status: "error",
+			reason: s.reason instanceof Error ? s.reason.message : String(s.reason)
+		});
+	} else for (const f of fixtures) {
+		const result = await runSingleFixture(f, client, options, config, history);
+		results.push(result);
+		if (result.status === "failed" || result.status === "error") break;
+	}
+	const runResults = results.filter((r) => r.status === "success" || r.status === "failed" || r.status === "cancelled").map((r) => ({
+		fixtureId: r.fixtureId,
+		runId: r.runId,
+		status: r.status,
+		totalDurationMs: r.durationMs ?? 0,
+		jobs: r.jobs ?? []
+	}));
+	if (options.json) console.log(formatJsonResult(runResults));
+	else if (options.junit) {
+		const junitXml = formatJunitResult(runResults);
+		await writeFile(options.junit, junitXml);
+		if (!options.quiet) logger.info(pc.green(`JUnit XML written to ${options.junit}`));
+	} else if (!options.quiet || results.some((r) => r.status !== "success" && r.status !== "accepted")) if (runResults.length > 1) logger.info(formatMultiFixtureSummary(runResults));
+	else displayRemoteResults(results);
+	return results.every((r) => r.status === "accepted" || r.status === "success");
+}
+/**
+* Run a single fixture remotely.
+*/
+async function runSingleFixture(fixture, client, options, config, history) {
+	const opts = typeof fixture.fixture.options === "function" ? await fixture.fixture.options() : fixture.fixture.options;
+	if (!options.quiet) logger.info(pc.cyan(`\n--- ${fixture.id} ---`));
+	try {
+		const kiciDir = resolveKiciDir(options.kiciDir);
+		const repoRoot = path.resolve(kiciDir, "..");
+		if (!options.quiet) logger.info(pc.gray("Creating overlay tarball..."));
+		const { tarballPath, summary, hasRemote } = await createOverlayTarball(repoRoot);
+		let routingKey = options.routingKey ?? config.routingKey ?? "default";
+		if (!hasRemote) {
+			routingKey = `local:${path.basename(repoRoot)}`;
+			logger.warn("No remote detected -- steps that use git commands will fail (no .git directory)");
+		}
+		let inlineLockFile;
+		if (!hasRemote) inlineLockFile = await readFile(path.join(kiciDir, "kici.lock.json"), "utf-8");
+		if (!options.quiet) {
+			logger.info(pc.gray(`${summary.fileCount} files changed, ${summary.newFiles} new, ${summary.deletedFiles} deleted (${formatBytes(summary.compressedSize)} compressed)`));
+			const sizeWarning = getSizeWarning(summary.compressedSize);
+			if (sizeWarning) logger.info(pc.yellow(sizeWarning));
+		}
+		if (!options.quiet) logger.info(pc.gray("Initializing upload..."));
+		const upload = await client.initUpload({
+			routingKey,
+			sha: summary.sha,
+			fileCount: summary.fileCount,
+			compressedSize: summary.compressedSize
+		});
+		if (!options.quiet) logger.info(pc.gray("Uploading overlay..."));
+		const uploadResult = await uploadTarball({
+			tarballPath,
+			signedUrl: upload.signedUrl,
+			orchestratorPublicKey: Buffer.from(upload.publicKey, "base64")
+		});
+		const event = buildEventFromFixture(opts);
+		if (!hasRemote) {
+			const repoName = path.basename(repoRoot);
+			const repo = event.payload.repository;
+			event.payload.repository = {
+				...repo ?? {},
+				full_name: `local/${repoName}`
+			};
+		}
+		if (!options.quiet) logger.info(pc.gray("Triggering test run..."));
+		const triggerResult = await client.triggerTest({
+			fixtureId: fixture.id,
+			event,
+			routingKey,
+			uploadId: upload.uploadId,
+			cliPublicKey: uploadResult.cliPublicKey.toString("base64"),
+			secrets: opts.secrets,
+			workflowName: opts.workflowName,
+			inlineLockFile,
+			fullRepo: !hasRemote || void 0
+		});
+		if (triggerResult.status === "rejected") {
+			if (!options.quiet) logger.info(pc.red(`Rejected: ${triggerResult.reason ?? "unknown reason"}`));
+			return {
+				fixtureId: fixture.id,
+				runId: triggerResult.runId,
+				status: "rejected",
+				reason: triggerResult.reason,
+				observeUrl: triggerResult.observeUrl
+			};
+		}
+		if (!options.quiet) {
+			logger.info(pc.green(`Run started: ${triggerResult.runId}`));
+			logger.info(pc.gray(`Observe: ${triggerResult.observeUrl}`));
+		}
+		const historyEndpoint = config.endpoint ?? config.platformEndpoint ?? "";
+		await history.addEntry({
+			runId: triggerResult.runId,
+			fixtureId: fixture.id,
+			status: "running",
+			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			endpoint: historyEndpoint
+		});
+		if (options.wait === false) return {
+			fixtureId: fixture.id,
+			runId: triggerResult.runId,
+			status: "accepted",
+			observeUrl: triggerResult.observeUrl
+		};
+		const result = await observeCompletion(fixture.id, triggerResult.runId, triggerResult.observeUrl, config.token, client, options);
+		await history.updateEntry(triggerResult.runId, {
+			status: result.status,
+			completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			durationMs: result.durationMs,
+			jobs: result.jobs
+		});
+		return result;
+	} catch (error) {
+		if (error instanceof AuthenticationError) logger.error(pc.red("Authentication failed. Run `kici login` to re-authenticate."));
+		else if (error instanceof ConnectionError) logger.error(pc.red(`Connection failed: ${error.message}`));
+		return {
+			fixtureId: fixture.id,
+			runId: "",
+			status: "error",
+			reason: toErrorMessage(error)
+		};
+	}
+}
+/**
+* Build a SimulatedEvent-compatible object from fixture options.
+*/
+function buildEventFromFixture(opts) {
+	const eventObj = opts.event;
+	const type = String(eventObj._type ?? "push");
+	const action = eventObj.action ? String(eventObj.action) : void 0;
+	const targetBranch = opts.branch ?? "main";
+	return {
+		type,
+		action,
+		targetBranch,
+		sourceBranch: type === "pr" ? opts.branch ?? "feature/test" : void 0,
+		payload: {
+			ref: `refs/heads/${targetBranch}`,
+			repository: { full_name: opts.repo ?? "owner/repo" },
+			...opts.sha && { after: opts.sha },
+			...opts.pr && { number: opts.pr }
+		}
+	};
+}
+/**
+* Observe run completion via WebSocket (primary path).
+* Falls back to HTTP polling if the WS connection fails.
+*/
+async function observeCompletion(fixtureId, runId, observeUrl, token, client, options) {
+	const formatter = new StreamingFormatter();
+	formatter.isQuiet = options.quiet ?? false;
+	const lastLinesByJob = /* @__PURE__ */ new Map();
+	const MAX_ERROR_LINES = 50;
+	let completionResult = null;
+	let fallbackToPolling = false;
+	const observer = new ObserverClient({
+		observeUrl,
+		token,
+		runId,
+		onLog: (msg) => {
+			for (const line of msg.lines) {
+				const output = formatter.formatLogLine(msg.jobName, msg.stepName, line);
+				if (output) process.stdout.write(output);
+			}
+			if (!lastLinesByJob.has(msg.jobName)) lastLinesByJob.set(msg.jobName, []);
+			const buffer = lastLinesByJob.get(msg.jobName);
+			buffer.push(...msg.lines);
+			while (buffer.length > MAX_ERROR_LINES) buffer.shift();
+		},
+		onStep: (msg) => {
+			const output = formatter.formatStepChange(msg.jobName, msg.stepName, msg.state, msg.durationMs);
+			if (output) process.stdout.write(output);
+		},
+		onStatus: (msg) => {
+			const output = formatter.formatStatusChange(msg.status, msg.jobName);
+			if (output) process.stdout.write(output);
+		},
+		onComplete: (msg) => {
+			completionResult = msg;
+		},
+		onError: (err) => {
+			if (options.debug) logger.error(pc.gray(`Observer error: ${err.message}`));
+			fallbackToPolling = true;
+		}
+	});
+	let cancelled = false;
+	const cancelHandler = async () => {
+		if (cancelled) return;
+		cancelled = true;
+		if (!options.quiet) logger.info(pc.yellow("\nCancelling test run..."));
+		observer.disconnect();
+		try {
+			const cancelResult = await client.cancelTest(runId);
+			if (!options.quiet) logger.info(pc.gray(`Cancel status: ${cancelResult.status}`));
+		} catch {}
+	};
+	process.on("SIGINT", cancelHandler);
+	try {
+		try {
+			await observer.connect();
+		} catch {
+			if (options.debug) logger.info(pc.gray("WebSocket connection failed, falling back to HTTP polling"));
+			process.removeListener("SIGINT", cancelHandler);
+			return await pollForCompletionFallback(fixtureId, runId, observeUrl, client, options);
+		}
+		formatter.startElapsedTimer();
+		let complete;
+		try {
+			complete = await observer.waitForCompletion();
+		} catch {
+			if (cancelled) return {
+				fixtureId,
+				runId,
+				status: "cancelled",
+				observeUrl
+			};
+			observer.disconnect();
+			process.removeListener("SIGINT", cancelHandler);
+			if (options.debug) logger.info(pc.gray("Observer disconnected, falling back to HTTP polling"));
+			return await pollForCompletionFallback(fixtureId, runId, observeUrl, client, options);
+		}
+		completionResult = complete;
+		formatter.stopElapsedTimer();
+		if (fallbackToPolling && !completionResult) {
+			observer.disconnect();
+			process.removeListener("SIGINT", cancelHandler);
+			if (options.debug) logger.info(pc.gray("Observer errored, falling back to HTTP polling"));
+			return await pollForCompletionFallback(fixtureId, runId, observeUrl, client, options);
+		}
+		const runResult = {
+			fixtureId,
+			runId,
+			status: complete.status,
+			totalDurationMs: complete.summary.totalDurationMs,
+			jobs: complete.summary.jobs
+		};
+		if (!options.quiet) process.stdout.write("\n" + formatSummary(runResult) + "\n");
+		if (complete.status === "failed") {
+			for (const job of complete.summary.jobs) if (job.status === "failed") {
+				const lines = lastLinesByJob.get(job.name);
+				if (lines && lines.length > 0 && !options.quiet) process.stdout.write("\n" + formatErrorHighlight(job.name, lines) + "\n");
+			}
+		}
+		observer.disconnect();
+		return {
+			fixtureId,
+			runId,
+			status: complete.status,
+			observeUrl,
+			durationMs: complete.summary.totalDurationMs,
+			jobs: complete.summary.jobs
+		};
+	} finally {
+		formatter.stopElapsedTimer();
+		process.removeListener("SIGINT", cancelHandler);
+	}
+}
+/**
+* Poll orchestrator for run completion (HTTP fallback when WebSocket fails).
+*/
+async function pollForCompletionFallback(fixtureId, runId, observeUrl, client, options) {
+	const POLL_INTERVAL_MS = 2e3;
+	const MAX_POLL_DURATION_MS = 1800 * 1e3;
+	const startTime = Date.now();
+	let cancelled = false;
+	const cancelHandler = async () => {
+		if (cancelled) return;
+		cancelled = true;
+		if (!options.quiet) logger.info(pc.yellow("\nCancelling test run..."));
+		try {
+			const cancelResult = await client.cancelTest(runId);
+			if (!options.quiet) logger.info(pc.gray(`Cancel status: ${cancelResult.status}`));
+		} catch {}
+	};
+	process.on("SIGINT", cancelHandler);
+	try {
+		while (!cancelled) {
+			if (Date.now() - startTime > MAX_POLL_DURATION_MS) return {
+				fixtureId,
+				runId,
+				status: "error",
+				reason: "Polling timeout exceeded (30 minutes)",
+				observeUrl
+			};
+			try {
+				const status = await client.getRunStatus(runId);
+				if (status.status === "success" || status.status === "failed" || status.status === "cancelled") {
+					const durationMs = Date.now() - startTime;
+					if (!options.quiet) {
+						const statusColor = status.status === "success" ? pc.green : pc.red;
+						logger.info(statusColor(`\nRun ${status.status} (${(durationMs / 1e3).toFixed(1)}s)`));
+						if (status.summary?.jobs) for (const job of status.summary.jobs) {
+							const jobColor = job.status === "success" ? pc.green : pc.red;
+							const duration = job.durationMs ? ` (${(job.durationMs / 1e3).toFixed(1)}s)` : "";
+							logger.info(`  ${jobColor(job.status.padEnd(10))} ${job.name}${duration}`);
+						}
+					}
+					return {
+						fixtureId,
+						runId,
+						status: status.status,
+						observeUrl,
+						durationMs: Date.now() - startTime,
+						jobs: status.summary?.jobs
+					};
+				}
+			} catch {}
+			await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+		}
+		return {
+			fixtureId,
+			runId,
+			status: "cancelled",
+			observeUrl,
+			durationMs: Date.now() - startTime
+		};
+	} finally {
+		process.removeListener("SIGINT", cancelHandler);
+	}
+}
+/**
+* Run a specific workflow directly (bypass trigger matching).
+*/
+async function runDirectWorkflow(workflowName, options) {
+	const config = await loadGlobalConfig();
+	if (!config.token) {
+		logger.error(pc.red("Not authenticated. Run `kici login` to set up your API key."));
+		return false;
+	}
+	const endpoint = config.endpoint ?? config.platformEndpoint;
+	if (!endpoint) {
+		logger.error(pc.red("No orchestrator endpoint configured. Run `kici login --endpoint <url>` to set one."));
+		return false;
+	}
+	const client = new OrchestratorClient({
+		endpoint,
+		token: config.token
+	});
+	if (!options.quiet) logger.info(pc.gray(`Running workflow "${workflowName}" directly (bypassing triggers)`));
+	const kiciDir = resolveKiciDir(options.kiciDir);
+	const repoRoot = path.resolve(kiciDir, "..");
+	const { tarballPath, summary, hasRemote } = await createOverlayTarball(repoRoot);
+	let routingKey = options.routingKey ?? config.routingKey ?? "default";
+	if (!hasRemote) {
+		routingKey = `local:${path.basename(repoRoot)}`;
+		logger.warn("No remote detected -- steps that use git commands will fail (no .git directory)");
+	}
+	let inlineLockFile;
+	if (!hasRemote) inlineLockFile = await readFile(path.join(kiciDir, "kici.lock.json"), "utf-8");
+	if (!options.quiet) logger.info(pc.gray(`${summary.fileCount} files changed, ${summary.newFiles} new, ${summary.deletedFiles} deleted (${formatBytes(summary.compressedSize)} compressed)`));
+	const upload = await client.initUpload({
+		routingKey,
+		sha: summary.sha,
+		fileCount: summary.fileCount,
+		compressedSize: summary.compressedSize
+	});
+	const directUploadResult = await uploadTarball({
+		tarballPath,
+		signedUrl: upload.signedUrl,
+		orchestratorPublicKey: Buffer.from(upload.publicKey, "base64")
+	});
+	const repoName = !hasRemote ? path.basename(repoRoot) : void 0;
+	const payload = {};
+	if (!hasRemote) payload.repository = { full_name: `local/${repoName}` };
+	const result = await client.triggerTest({
+		fixtureId: `direct:${workflowName}`,
+		event: {
+			type: "manual",
+			targetBranch: "main",
+			payload
+		},
+		routingKey,
+		uploadId: upload.uploadId,
+		cliPublicKey: directUploadResult.cliPublicKey.toString("base64"),
+		workflowName,
+		inlineLockFile,
+		fullRepo: !hasRemote || void 0
+	});
+	if (!options.quiet) {
+		logger.info(pc.green(`Run started: ${result.runId}`));
+		logger.info(pc.gray(`Observe: ${result.observeUrl}`));
+	}
+	if (options.wait === false) return result.status === "accepted";
+	const observeResult = await observeCompletion(`direct:${workflowName}`, result.runId, result.observeUrl, config.token, client, options);
+	return observeResult.status === "success" || observeResult.status === "accepted";
+}
+/**
+* Display remote run results as a summary table.
+*/
+function displayRemoteResults(results) {
+	logger.info(pc.bold("\n--- Results ---\n"));
+	for (const r of results) {
+		const statusColor = r.status === "success" || r.status === "accepted" ? pc.green : r.status === "cancelled" ? pc.yellow : pc.red;
+		const duration = r.durationMs ? ` (${(r.durationMs / 1e3).toFixed(1)}s)` : "";
+		logger.info(`  ${statusColor(r.status.padEnd(12))} ${r.fixtureId}${duration}`);
+		if (r.reason) logger.info(pc.gray(`    ${r.reason}`));
+	}
+	const passed = results.filter((r) => r.status === "success" || r.status === "accepted").length;
+	const failed = results.length - passed;
+	logger.info("");
+	if (failed === 0) logger.info(pc.green(`All ${results.length} fixture(s) passed`));
+	else logger.info(pc.red(`${failed} of ${results.length} fixture(s) failed`));
+	logger.info("");
+}
+//#endregion
+export { observeCompletion, runLocalCommand, runRemoteCommand };
+
+//# sourceMappingURL=run.js.map

package/dist/commands/secrets-list.d.ts

@@ -0,0 +1,16 @@
+export interface SecretsListOptions {
+    /** Orchestrator endpoint override (defaults to global config). */
+    endpoint?: string;
+}
+/**
+ * List test-available secret contexts from the orchestrator.
+ *
+ * Loads the global config for auth token and active org, calls
+ * GET /api/v1/admin/environments?orgId=<org>&includeSecrets=true,
+ * filters to envs with allow_local_execution=true, and displays a
+ * table of names, key names, and flags.
+ *
+ * Values are never exposed -- only key names.
+ */
+export declare function secretsListCommand(options: SecretsListOptions): Promise<boolean>;
+//# sourceMappingURL=secrets-list.d.ts.map

package/dist/commands/secrets-list.js

@@ -0,0 +1,85 @@
+import "../chunk-gOLHoazu.js";
+import { loadGlobalConfig } from "../remote/config.js";
+import pc from "picocolors";
+import { toErrorMessage } from "@kici-dev/shared";
+//#region src/commands/secrets-list.ts
+/**
+* List test-available secret contexts from the orchestrator.
+*
+* Loads the global config for auth token and active org, calls
+* GET /api/v1/admin/environments?orgId=<org>&includeSecrets=true,
+* filters to envs with allow_local_execution=true, and displays a
+* table of names, key names, and flags.
+*
+* Values are never exposed -- only key names.
+*/
+async function secretsListCommand(options) {
+	try {
+		const config = await loadGlobalConfig();
+		if (!config.token) {
+			console.error(pc.red("Not authenticated. Run `kici login` first."));
+			return false;
+		}
+		const endpoint = options.endpoint ?? config.endpoint;
+		if (!endpoint) {
+			console.error(pc.red("No orchestrator endpoint configured. Run `kici login --endpoint <url>` first."));
+			return false;
+		}
+		if (!config.activeOrgId) {
+			console.error(pc.red("No active organization. Run `kici org list` then `kici org use <name>` first."));
+			return false;
+		}
+		const url = `${endpoint.replace(/\/+$/, "")}/api/v1/admin/environments?orgId=${encodeURIComponent(config.activeOrgId)}&includeSecrets=true`;
+		const res = await fetch(url, { headers: { Authorization: `Bearer ${config.token}` } });
+		if (res.status === 401) {
+			console.error(pc.red("Authentication failed. Check your API key with `kici login`."));
+			return false;
+		}
+		if (res.status === 403) {
+			console.error(pc.red("Permission denied. Your API key does not have secret.read access."));
+			return false;
+		}
+		if (!res.ok) {
+			const text = await res.text();
+			console.error(pc.red(`Failed to fetch contexts: ${res.status} ${text}`));
+			return false;
+		}
+		const contexts = ((await res.json()).environments ?? []).filter((e) => e.allow_local_execution);
+		if (contexts.length === 0) {
+			console.log(pc.yellow("No test-available secret contexts found."));
+			console.log(pc.gray("Set allowLocalExecution=true on an environment to make its secrets available for test runs."));
+			return true;
+		}
+		console.log(pc.bold("\nTest-available secret contexts:\n"));
+		const ctxKeys = (c) => c.secret_keys ?? [];
+		const nameWidth = Math.max(7, ...contexts.map((c) => c.name.length));
+		const keysWidth = Math.max(4, ...contexts.map((c) => {
+			const k = ctxKeys(c);
+			return k.length > 0 ? k.join(", ").length : 4;
+		}));
+		const flagsWidth = Math.max(5, ...contexts.map((c) => c.enabled ? 0 : 8));
+		const pad = (s, w) => s.padEnd(w);
+		const hr = (w) => "─".repeat(w);
+		console.log(`\u250c${hr(nameWidth + 2)}\u252c${hr(keysWidth + 2)}\u252c${hr(flagsWidth + 2)}\u2510`);
+		console.log(`\u2502 ${pad("Context", nameWidth)} \u2502 ${pad("Keys", keysWidth)} \u2502 ${pad("Flags", flagsWidth)} \u2502`);
+		console.log(`\u251c${hr(nameWidth + 2)}\u253c${hr(keysWidth + 2)}\u253c${hr(flagsWidth + 2)}\u2524`);
+		for (const ctx of contexts) {
+			const k = ctxKeys(ctx);
+			const keys = k.length > 0 ? k.join(", ") : pc.gray("none");
+			const keysRaw = k.length > 0 ? k.join(", ") : "none";
+			const flagStr = ctx.enabled ? "" : "disabled";
+			console.log(`\u2502 ${pad(ctx.name, nameWidth)} \u2502 ${keys}${" ".repeat(Math.max(0, keysWidth - keysRaw.length))} \u2502 ${pad(flagStr, flagsWidth)} \u2502`);
+		}
+		console.log(`\u2514${hr(nameWidth + 2)}\u2534${hr(keysWidth + 2)}\u2534${hr(flagsWidth + 2)}\u2518`);
+		console.log("");
+		return true;
+	} catch (err) {
+		const message = toErrorMessage(err);
+		console.error(pc.red(`Failed to list secrets: ${message}`));
+		return false;
+	}
+}
+//#endregion
+export { secretsListCommand };
+
+//# sourceMappingURL=secrets-list.js.map

package/dist/commands/status.d.ts

@@ -0,0 +1,30 @@
+/**
+ * kici status command
+ *
+ * Shows the status and details of a test run, with optional log streaming.
+ * Looks up local history first, then fetches from the orchestrator for
+ * up-to-date status and logs.
+ */
+/** Options for the status command */
+export interface StatusOptions {
+    /** Stream full log replay to stdout */
+    logs?: boolean;
+    /** Filter logs to specific job */
+    job?: string;
+    /** Output raw JSON response */
+    json?: boolean;
+}
+/**
+ * Show status and details of a test run.
+ *
+ * Default mode: show run summary table from local history + orchestrator.
+ * --logs: stream full logs from the orchestrator.
+ * --job <name>: filter logs to a specific job.
+ * --json: output raw JSON.
+ *
+ * @param runId - The run ID to inspect
+ * @param options - Status display options
+ * @returns true on success, false on error
+ */
+export declare function statusCommand(runId: string, options?: StatusOptions): Promise<boolean>;
+//# sourceMappingURL=status.d.ts.map