@keystrokehq/cli 0.0.32 → 0.0.38

package/dist/{users.set-role.handler-Djw1_VGf.mjs → users.set-role.handler-koRzA0V9.mjs}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
-import { a as ui } from "./keystroke.mjs";
-import { i as writeJson } from "./output-BWcVRt-T.mjs";
-import { i as requireClient } from "./context-sgKhRc5v.mjs";
-import { n as isIamJsonMode, r as requireConfirmation, t as handleIamError } from "./iam-command-utils-CSZj4XlH.mjs";
+import { p as ui } from "./keystroke.mjs";
+import { i as writeJson } from "./output-BPydP5tG.mjs";
+import { i as requireClient } from "./context-Brc9VGV9.mjs";
+import { n as isIamJsonMode, r as requireConfirmation, t as handleIamError } from "./iam-command-utils-D01Gw8-M.mjs";
 //#region src/commands/admin/users.set-role.handler.ts
 async function handleAdminUsersSetRole(options, ctx) {
 	const client = requireClient(ctx);

package/dist/{validate.handler-Drf_lssw.mjs → validate.handler-BkBsS8BL.mjs}

@@ -1,21 +1,17 @@
 #!/usr/bin/env node
 
-import { a as ui, j as throwReportedCliExit, y as toErrorMessage } from "./keystroke.mjs";
-import { i as projects } from "./dist-Dw7gCE7y.mjs";
-import { i as writeJson } from "./output-BWcVRt-T.mjs";
-import { t as requireWorkflowsDir } from "./resolve-project-E9mrh_el.mjs";
-import { s as build, t as WorkflowNotFoundError } from "./workflow-build-Begvjfq8.mjs";
-import { t as createBuildProgress } from "./build-progress-DLM1Bt4T.mjs";
+import { P as throwReportedCliExit, S as toErrorMessage, p as ui } from "./keystroke.mjs";
+import { i as projects } from "./dist-B5jy238v.mjs";
+import { i as writeJson } from "./output-BPydP5tG.mjs";
+import { a as readManifestsFromOutDir } from "./dist-BmbFJq8U.mjs";
+import { t as requireWorkflowsDir } from "./resolve-project-CoCN9xfi.mjs";
+import { c as build, s as typecheckWorkflows, t as WorkflowNotFoundError } from "./workflow-build-Db6at6IA.mjs";
+import { t as createBuildProgress } from "./build-progress-D_SQqdHA.mjs";
+import { n as assertAuthoredWorkflowId, t as WORKFLOW_ID_COMMANDS } from "./authored-workflow-ref-BRCQgyWl.mjs";
 import * as path$1 from "node:path";
 import * as os from "node:os";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdtemp, readFile, readdir, rm } from "node:fs/promises";
 //#region src/commands/workflows/validate/workflow-validate.ts
-/**
-* workflow-validate.ts
-*
-* Validation-only build: runs analysis phases without
-* writing any permanent output artifacts. Uses a temp dir cleaned up afterwards.
-*/
 var WorkflowValidationFailedError = class extends Error {
 	result;
 	constructor(result) {
@@ -42,12 +38,13 @@ async function runWorkflowValidate(options) {
 		});
 	}
 	const totalMs = Date.now() - startTime;
-	let result = mapBuildResultToValidateResult(buildResult, totalMs);
+	let result = await mapBuildResultToValidateResult(buildResult, totalMs);
+	if (options.typecheck !== false) result = await appendTypecheckToValidateResult(result, options.workflowsDir);
 	result = filterValidationResult(result, options.workflow);
 	if (!result.success) throw new WorkflowValidationFailedError(result);
 	return result;
 }
-function mapBuildResultToValidateResult(buildResult, totalMs) {
+async function mapBuildResultToValidateResult(buildResult, totalMs) {
 	const workflowMap = /* @__PURE__ */ new Map();
 	for (const artifact of buildResult.artifacts) workflowMap.set(artifact.manifest.id, {
 		id: artifact.manifest.id,
@@ -56,6 +53,7 @@ function mapBuildResultToValidateResult(buildResult, totalMs) {
 		issues: []
 	});
 	for (const failure of buildResult.failures) appendFailureIssue(workflowMap, failure);
+	await enrichAuthoredWorkflowIds(workflowMap);
 	if (buildResult.warnings.length > 0) workflowMap.set("__project__", {
 		name: "project",
 		filePath: "",
@@ -79,11 +77,13 @@ function mapBuildResultToValidateResult(buildResult, totalMs) {
 function appendFailureIssue(workflowMap, failure) {
 	if (failure.kind === "workflow" || failure.kind === "loader-protocol") {
 		const key = failure.workflow.resolvedFilePath;
-		const existing = workflowMap.get(key) ?? workflowMap.get(failure.workflow.workflowId ?? "") ?? createWorkflowValidateStats({
-			id: failure.workflow.workflowId,
+		const authoredId = failure.workflow.workflowId ?? resolveAuthoredIdFromWorkflowMap(workflowMap, failure.workflow.resolvedFilePath);
+		const existing = workflowMap.get(key) ?? workflowMap.get(authoredId ?? "") ?? createWorkflowValidateStats({
+			id: authoredId,
 			name: path$1.basename(failure.workflow.resolvedFilePath, path$1.extname(failure.workflow.resolvedFilePath)),
 			filePath: failure.workflow.resolvedFilePath
 		});
+		if (!existing.id && authoredId) existing.id = authoredId;
 		existing.issues.push({
 			severity: "error",
 			file: failure.workflow.resolvedFilePath,
@@ -142,6 +142,7 @@ function appendFailureIssue(workflowMap, failure) {
 	if (failure.kind === "trigger") {
 		const key = `trigger:${failure.workflowId}:${failure.triggerExportName}`;
 		const existing = workflowMap.get(key) ?? createWorkflowValidateStats({
+			id: failure.workflowId,
 			name: failure.triggerId,
 			filePath: ""
 		});
@@ -198,6 +199,136 @@ function appendFailureIssue(workflowMap, failure) {
 	});
 	workflowMap.set(key, existing);
 }
+function resolveAuthoredIdFromWorkflowMap(workflowMap, filePath) {
+	for (const stats of workflowMap.values()) if (stats.id && stats.filePath === filePath) return stats.id;
+}
+const AUTHORED_WORKFLOW_ID_PATTERN = /\bid:\s*['"]([^'"]+)['"]/;
+async function readAuthoredWorkflowIdFromSource(filePath) {
+	const source = await readFile(filePath, "utf-8").catch(() => null);
+	if (!source) return;
+	return AUTHORED_WORKFLOW_ID_PATTERN.exec(source)?.[1];
+}
+async function collectWorkflowTypeScriptFiles(projectRoot) {
+	const workflowsRoot = path$1.join(projectRoot, "workflows");
+	const files = [];
+	async function walk(dir) {
+		let entries = [];
+		try {
+			entries = await readdir(dir, {
+				withFileTypes: true,
+				encoding: "utf8"
+			});
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (entry.name === "node_modules" || entry.name === "dist") continue;
+			const fullPath = path$1.join(dir, entry.name);
+			if (entry.isDirectory()) await walk(fullPath);
+			else if (entry.isFile() && /\.tsx?$/.test(entry.name)) files.push(fullPath);
+		}
+	}
+	await walk(workflowsRoot);
+	return files;
+}
+function findWorkflowStatsForDiagnosticFile(workflowMap, diagnosticFile) {
+	const resolvedFile = path$1.resolve(diagnosticFile);
+	for (const stats of workflowMap.values()) {
+		if (!stats.filePath) continue;
+		const workflowFile = path$1.resolve(stats.filePath);
+		const workflowDir = path$1.dirname(workflowFile);
+		if (resolvedFile === workflowFile || resolvedFile.startsWith(`${workflowDir}${path$1.sep}`)) return stats;
+	}
+	const fallback = createWorkflowValidateStats({
+		name: path$1.basename(resolvedFile, path$1.extname(resolvedFile)),
+		filePath: resolvedFile
+	});
+	workflowMap.set(resolvedFile, fallback);
+	return fallback;
+}
+function appendTypecheckDiagnostic(workflowMap, diagnostic) {
+	if (!diagnostic.file) {
+		const projectStats = workflowMap.get("__project__") ?? createWorkflowValidateStats({
+			name: "project",
+			filePath: ""
+		});
+		projectStats.issues.push({
+			severity: diagnostic.severity,
+			message: diagnostic.message,
+			type: "analysis"
+		});
+		workflowMap.set("__project__", projectStats);
+		return;
+	}
+	findWorkflowStatsForDiagnosticFile(workflowMap, diagnostic.file).issues.push({
+		severity: diagnostic.severity,
+		file: path$1.resolve(diagnostic.file),
+		line: diagnostic.line,
+		message: diagnostic.message,
+		type: "analysis"
+	});
+}
+async function appendTypecheckToValidateResult(result, projectRoot) {
+	const workflowMap = /* @__PURE__ */ new Map();
+	for (const workflow of result.workflows) {
+		const key = workflow.id ?? (workflow.filePath ? `file:${workflow.filePath}` : `name:${workflow.name}`);
+		workflowMap.set(key, workflow);
+	}
+	const files = await collectWorkflowTypeScriptFiles(projectRoot);
+	if (files.length === 0) return result;
+	try {
+		const typecheckResult = await typecheckWorkflows({
+			projectRoot,
+			files
+		});
+		if (typecheckResult.toolFailure) {
+			const projectStats = workflowMap.get("__project__") ?? createWorkflowValidateStats({
+				name: "project",
+				filePath: ""
+			});
+			projectStats.issues.push({
+				severity: "error",
+				message: typecheckResult.toolFailure.message,
+				type: "other"
+			});
+			workflowMap.set("__project__", projectStats);
+		}
+		for (const diagnostic of typecheckResult.diagnostics) appendTypecheckDiagnostic(workflowMap, diagnostic);
+	} catch (error) {
+		const projectStats = workflowMap.get("__project__") ?? createWorkflowValidateStats({
+			name: "project",
+			filePath: ""
+		});
+		projectStats.issues.push({
+			severity: "error",
+			message: toErrorMessage(error),
+			type: "other"
+		});
+		workflowMap.set("__project__", projectStats);
+	}
+	await enrichAuthoredWorkflowIds(workflowMap);
+	const workflows = [...workflowMap.values()];
+	const errorCount = workflows.reduce((count, workflow) => count + workflow.issues.filter((issue) => issue.severity === "error").length, 0);
+	const warningCount = workflows.reduce((count, workflow) => count + workflow.issues.filter((issue) => issue.severity === "warning").length, 0);
+	return {
+		...result,
+		success: errorCount === 0,
+		workflows,
+		errorCount,
+		warningCount
+	};
+}
+async function enrichAuthoredWorkflowIds(workflowMap) {
+	for (const stats of workflowMap.values()) {
+		if (stats.id || !stats.filePath) continue;
+		const fromArtifacts = resolveAuthoredIdFromWorkflowMap(workflowMap, stats.filePath);
+		if (fromArtifacts) {
+			stats.id = fromArtifacts;
+			continue;
+		}
+		stats.id = await readAuthoredWorkflowIdFromSource(stats.filePath);
+	}
+}
 function createWorkflowValidateStats(stats) {
 	return {
 		id: stats.id,
@@ -206,14 +337,19 @@ function createWorkflowValidateStats(stats) {
 		issues: []
 	};
 }
+/** Matches an authored workflow id or failures scoped to that workflow's source tree. */
+function workflowMatchesValidateRef(workflow, workflowRef) {
+	if (workflow.id === workflowRef) return true;
+	if (!workflow.filePath) return false;
+	const normalizedRef = workflowRef.replaceAll("\\", "/");
+	const normalizedPath = workflow.filePath.replaceAll("\\", "/");
+	if (normalizedPath.includes(`/${normalizedRef}/`) || normalizedPath.endsWith(`/${normalizedRef}.workflow.ts`)) return true;
+	return path$1.basename(normalizedPath, path$1.extname(normalizedPath)) === normalizedRef;
+}
 function filterValidationResult(result, workflowRef) {
 	if (!workflowRef) return result;
-	const matching = result.workflows.filter((workflow) => workflow.id === workflowRef || workflow.name === workflowRef || path$1.basename(workflow.filePath, path$1.extname(workflow.filePath)) === workflowRef);
-	if (matching.length === 0) {
-		const availableNames = result.workflows.map((workflow) => workflow.name).filter((name) => name !== "project");
-		const availableIds = result.workflows.map((workflow) => workflow.id).filter((id) => id !== void 0);
-		throw new WorkflowNotFoundError(workflowRef, availableNames.length > 0 ? availableNames : availableIds);
-	}
+	const matching = result.workflows.filter((workflow) => workflowMatchesValidateRef(workflow, workflowRef));
+	if (matching.length === 0) throw new WorkflowNotFoundError(workflowRef, [...new Set(result.workflows.map((workflow) => workflow.id).filter((id) => id !== void 0))]);
 	return {
 		...result,
 		success: matching.every((workflow) => workflow.issues.every((issue) => issue.severity !== "error")),
@@ -232,6 +368,10 @@ function renderValidateSummary(result) {
 		ui.success(`Validation passed — ${workflowLabel}, ${result.errorCount} errors, ${result.warningCount} warnings`);
 	}
 }
+function formatValidateWorkflowLabel(workflow) {
+	if (workflow.id) return `workflow id: ${workflow.id}`;
+	return `workflow: ${workflow.name}`;
+}
 function renderValidateFailure(error, asJson) {
 	if (error instanceof WorkflowValidationFailedError) {
 		if (!asJson) {
@@ -239,15 +379,15 @@ function renderValidateFailure(error, asJson) {
 			for (const workflow of error.result.workflows) for (const issue of workflow.issues.filter((i) => i.severity === "error")) {
 				const loc = issue.file ? issue.line !== void 0 ? `${issue.file}:${issue.line}` : issue.file : "";
 				ui.hint(`  ${loc ? `${loc} — ` : ""}${issue.message}`);
-				ui.hint(`    workflow: ${workflow.name}`);
+				ui.hint(`    ${formatValidateWorkflowLabel(workflow)}`);
 				ui.hint(`    type: ${issue.type}`);
 			}
 		} else writeJson(error.result);
 		return;
 	}
 	if (error instanceof WorkflowNotFoundError) {
-		ui.error(`Workflow "${error.workflowName}" not found.`);
-		if (error.availableNames.length > 0) ui.hint(`Available: ${error.availableNames.join(", ")}`);
+		ui.error(`Workflow "${error.workflowRef}" not found.`);
+		if (error.availableIds.length > 0) ui.hint(`Available workflow ids: ${error.availableIds.join(", ")}`);
 		return;
 	}
 	ui.error(`Validation error: ${toErrorMessage(error)}`);
@@ -257,6 +397,10 @@ function renderValidateFailure(error, asJson) {
 async function handleWorkflowsValidate(options, ctx) {
 	const workflowsDir = await requireWorkflowsDir(options.path);
 	projects.track(workflowsDir);
+	if (options.workflow) {
+		const manifests = await readManifestsFromOutDir(workflowsDir);
+		await assertAuthoredWorkflowId(options.workflow, workflowsDir, WORKFLOW_ID_COMMANDS.validate, { refreshManifests: manifests.length === 0 });
+	}
 	const { jsonMode } = ctx;
 	renderValidateHeader(options.workflow);
 	const progress = createBuildProgress(options.workflow ?? "all workflows");
@@ -264,6 +408,7 @@ async function handleWorkflowsValidate(options, ctx) {
 		const result = await runWorkflowValidate({
 			workflowsDir,
 			verbose: options.verbose,
+			typecheck: options.typecheck,
 			workflow: options.workflow,
 			onProgressEvent: progress.handleEvent
 		});