@keystrokehq/cli 0.0.1

package/dist/build-progress-DgYKb4hB.mjs

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+
+import { i as logger } from "./keystroke.mjs";
+import { n as formatProgressDuration, t as createSpinnerProgress } from "./spinner-progress-DMVwgqO9.mjs";
+//#region src/lib/build-progress.ts
+const NEW_STAGE_LABELS = {
+	start: "Starting build",
+	cached: "Using cached artifact",
+	success: "Complete",
+	failure: "Failed"
+};
+const PHASE_SCAN = "scan";
+const PHASE_BUILD = "build";
+const PHASE_OUTPUT = "output";
+const PHASE_METADATA = "metadata";
+function formatArtifactCount(count, kind) {
+	return `${count} ${kind}(s)`;
+}
+function formatArtifactSummaryCount(count, kind) {
+	return `${count} ${kind}${count === 1 ? "" : "s"}`;
+}
+function formatArtifactSummary(workflowCount, agentCount) {
+	const parts = [];
+	if (workflowCount > 0 || agentCount === 0) parts.push(formatArtifactSummaryCount(workflowCount, "workflow"));
+	if (agentCount > 0) parts.push(formatArtifactSummaryCount(agentCount, "agent"));
+	return parts.length > 1 ? `${parts.slice(0, -1).join(", ")} and ${parts.at(-1)}` : parts[0] ?? formatArtifactSummaryCount(0, "workflow");
+}
+function formatOutputCompleteLabel(event) {
+	const { writtenCount, skippedWriteCount } = event;
+	if (skippedWriteCount === void 0 || skippedWriteCount === 0) return writtenCount === 1 ? "Wrote 1 artifact" : `Wrote ${writtenCount} artifact(s)`;
+	return `Wrote ${writtenCount - skippedWriteCount} of ${writtenCount} artifact(s)\n${skippedWriteCount === 1 ? "1 unchanged on disk" : `${skippedWriteCount} unchanged on disk`}`;
+}
+/**
+* Multi-line label: line 1 is short; following lines are dim detail (see spinner-worker).
+* Avoids one huge truncated line in narrow terminals.
+*/
+function formatBuildCompleteLabel(event) {
+	const workflowTotal = event.workflowBuiltCount + event.cachedWorkflowCount;
+	const agentTotal = event.agentBuiltCount + event.cachedAgentCount;
+	const builtParts = [];
+	if (workflowTotal > 0 || agentTotal === 0) builtParts.push(formatArtifactCount(workflowTotal, "workflow"));
+	if (agentTotal > 0) builtParts.push(formatArtifactCount(agentTotal, "agent"));
+	const lines = [`Bundled ${builtParts.length > 1 ? `${builtParts.slice(0, -1).join(", ")} and ${builtParts.at(-1)}` : builtParts[0] ?? formatArtifactCount(0, "workflow")}`];
+	const hasTiming = event.cacheResolutionMs !== void 0 && event.bundlePipelineMs !== void 0;
+	if (event.cacheResolutionMs !== void 0 && event.bundlePipelineMs !== void 0) lines.push(`cache ${formatProgressDuration(event.cacheResolutionMs)} · bundle ${formatProgressDuration(event.bundlePipelineMs)}`);
+	const builtWf = event.workflowBuiltCount;
+	const builtAg = event.agentBuiltCount;
+	const cachedWf = event.cachedWorkflowCount;
+	const cachedAg = event.cachedAgentCount;
+	if (builtWf === 0 && builtAg === 0 && cachedWf + cachedAg > 0) {
+		if (!hasTiming) lines.push("all bundle cache hits");
+	} else if (cachedWf > 0 || cachedAg > 0) {
+		const fromCacheParts = [];
+		if (cachedWf > 0) fromCacheParts.push(`${cachedWf} workflow${cachedWf === 1 ? "" : "s"}`);
+		if (cachedAg > 0) fromCacheParts.push(`${cachedAg} agent${cachedAg === 1 ? "" : "s"}`);
+		const fromCacheStr = `from cache: ${fromCacheParts.join(", ")}`;
+		if (builtWf > 0 || builtAg > 0) {
+			const rebuiltParts = [];
+			if (builtWf > 0) rebuiltParts.push(`${builtWf} workflow${builtWf === 1 ? "" : "s"}`);
+			if (builtAg > 0) rebuiltParts.push(`${builtAg} agent${builtAg === 1 ? "" : "s"}`);
+			lines.push(`${fromCacheStr} · rebuilt: ${rebuiltParts.join(", ")}`);
+		}
+	}
+	return lines.join("\n");
+}
+function formatDiscoveryStartLabel(filesTotal) {
+	return filesTotal === 1 ? "Scanning 1 file for workflows and agents..." : `Scanning ${filesTotal} files for workflows and agents...`;
+}
+function formatDiscoveryScanLabel(filesScanned, filesTotal) {
+	return `Scanning files for workflows and agents... (${filesScanned}/${filesTotal})`;
+}
+function formatDiscoveryCompleteLabel(workflowCount, agentCount, filesScanned) {
+	return `Found ${formatArtifactSummary(workflowCount, agentCount)} in ${filesScanned} file(s)`;
+}
+function formatBuildStartLabel(workflowName, workflowCount, agentCount) {
+	return workflowCount === 1 && agentCount === 0 ? `Building "${workflowName}"...` : `Building ${formatArtifactSummary(workflowCount, agentCount)}...`;
+}
+function formatMetadataStartLabel(fileCount) {
+	if (fileCount === 0) return "Discovering metadata files...";
+	if (fileCount === 1) return "Generating metadata for 1 file...";
+	return `Generating metadata for ${fileCount} file(s)...`;
+}
+function createBuildProgress(workflowName) {
+	logger.info(`[build] Starting: "${workflowName}"`);
+	const spinner = createSpinnerProgress("[build]");
+	let buildStartTime;
+	function getStageLabel(stage) {
+		return NEW_STAGE_LABELS[stage];
+	}
+	function getFailureMessage(event) {
+		let message = "Build failed";
+		if ("failure" in event) message = event.failure.error;
+		else if ("error" in event && typeof event.error === "string" && event.error.length > 0) message = event.error;
+		const firstLine = message.split("\n")[0] ?? message;
+		return firstLine.length > 120 ? `${firstLine.slice(0, 120)}…` : firstLine;
+	}
+	spinner.addPendingPhase(PHASE_SCAN, "Scan workflows and agents");
+	spinner.addPendingPhase(PHASE_BUILD, "Build workflows and agents");
+	spinner.addPendingPhase(PHASE_OUTPUT, "Write build output");
+	spinner.addPendingPhase(PHASE_METADATA, "File metadata");
+	function handleWorkflowStage(event) {
+		const { stage, workflowIndex, workflowCount } = event;
+		if (stage === "start") {
+			logger.info(`[build] → workflow ${workflowIndex}/${workflowCount}: ${stage}`);
+			return;
+		}
+		if (stage === "cached" || stage === "success") {
+			logger.info(`[build] ✓ workflow ${workflowIndex}/${workflowCount} ${stage === "cached" ? "cached" : "succeeded"} (${formatProgressDuration(event.elapsedMs)})`);
+			return;
+		}
+		if (stage === "failure") {
+			spinner.failPhase(PHASE_BUILD, "Build failed", event.elapsedMs, getFailureMessage(event));
+			logger.info(`[build] ✗ workflow ${workflowIndex}/${workflowCount} failed: ${getFailureMessage(event)}`);
+			return;
+		}
+		spinner.updatePhase(PHASE_BUILD, getStageLabel(stage));
+	}
+	function handleEvent(event) {
+		switch (event.phase) {
+			case "discovery-start":
+				spinner.startPhase(PHASE_SCAN, formatDiscoveryStartLabel(event.filesTotal));
+				return;
+			case "discovery-scan":
+				spinner.updatePhase(PHASE_SCAN, formatDiscoveryScanLabel(event.filesScanned, event.filesTotal));
+				return;
+			case "discovery-complete":
+				spinner.completePhase(PHASE_SCAN, formatDiscoveryCompleteLabel(event.workflowCount, event.agentCount, event.filesScanned), event.elapsedMs);
+				return;
+			case "cache-stats":
+				logger.info(`[build] cache stats: cacheHits=${event.cacheHits}, cacheMisses=${event.cacheMisses}, invalidated=${event.invalidated}`);
+				return;
+			case "build-start":
+				buildStartTime = Date.now();
+				spinner.startPhase(PHASE_BUILD, formatBuildStartLabel(workflowName, event.workflowCount, event.agentCount));
+				return;
+			case "workflow-stage":
+				handleWorkflowStage(event);
+				return;
+			case "build-complete":
+				if (buildStartTime !== void 0 && event.failedCount === 0) spinner.completePhase(PHASE_BUILD, formatBuildCompleteLabel(event), event.elapsedMs);
+				return;
+			case "duplicate-id-conflict":
+				logger.info(`[build] duplicate workflow id conflict: ${event.workflowId} (${event.files.join(", ")})`);
+				return;
+			case "output-start":
+				spinner.startPhase(PHASE_OUTPUT, event.artifactCount === 1 ? "Writing 1 artifact to disk..." : `Writing ${event.artifactCount} artifact(s) to disk...`);
+				return;
+			case "output-complete":
+				spinner.completePhase(PHASE_OUTPUT, formatOutputCompleteLabel(event), event.elapsedMs);
+				return;
+			case "metadata-start":
+				spinner.startPhase(PHASE_METADATA, formatMetadataStartLabel(event.fileCount));
+				return;
+			case "metadata-scan":
+				spinner.updatePhase(PHASE_METADATA, `Generating metadata... (${event.filesProcessed}/${event.filesTotal})`);
+				return;
+			case "metadata-cache-stats":
+				spinner.updatePhase(PHASE_METADATA, "Merging metadata...");
+				logger.info(`[build] metadata cache stats: cacheHits=${event.cacheHits}, cacheMisses=${event.cacheMisses}, invalidated=${event.invalidated}`);
+				return;
+			case "metadata-complete":
+				spinner.completePhase(PHASE_METADATA, `Generated metadata for ${event.fileCount} file(s)`, event.elapsedMs);
+				return;
+			case "metadata-output-complete":
+				logger.info(`[build] metadata output: written=${event.writtenCount}, cleaned=${event.cleanedCount} (${formatProgressDuration(event.elapsedMs)})`);
+				return;
+			case "convention-errors":
+				spinner.failPhase(PHASE_METADATA, `${event.errorCount} file convention error(s)`, 0);
+				return;
+			case "complete": return;
+		}
+	}
+	function stop() {
+		if (spinner.isRunning()) logger.info(`[build] stopped (phase: "${spinner.currentLabel()}")`);
+		spinner.stop();
+	}
+	return {
+		handleEvent,
+		stop
+	};
+}
+//#endregion
+export { createBuildProgress as t };

package/dist/build-tasks-CdihpudT-D5r5HUHe.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+import { t as TaskBuildManifestSchema } from "./schemas-CDib1RhE.mjs";
+import "./task-B2sZMaZu.mjs";
+import { n as bundleWorkflowTarget } from "./workflow-bundler-BPiqVscj-X1PFFAuP.mjs";
+import { t as buildTriggerArtifacts } from "./trigger-artifacts-DQPbQNqC-B4yeeFBY.mjs";
+import { performance } from "node:perf_hooks";
+//#region ../../packages/workflow-builder/dist/build-tasks-CdihpudT.mjs
+async function buildTaskArtifact(options) {
+	const { discoveredWorkflow, taskMetadata, projectRoot } = options;
+	const totalStartedAt = performance.now();
+	const bundle = await bundleWorkflowTarget({
+		filePath: discoveredWorkflow.resolvedFilePath,
+		localExportName: discoveredWorkflow.localExportName,
+		projectRoot,
+		sourceMap: options.sourceMaps
+	});
+	const bundleMs = performance.now() - totalStartedAt - taskMetadata.timing.importMs;
+	const manifestData = TaskBuildManifestSchema.parse(taskMetadata.manifest);
+	const triggerStartedAt = performance.now();
+	const triggerResult = await buildTriggerArtifacts(taskMetadata.triggers, manifestData.id, manifestData.name, projectRoot, {
+		workflowExportName: discoveredWorkflow.localExportName,
+		workflowFilePath: discoveredWorkflow.resolvedFilePath
+	});
+	const triggerMs = performance.now() - triggerStartedAt;
+	return {
+		artifact: {
+			task: {
+				bindingKey: discoveredWorkflow.bindingKey,
+				exportFilePath: discoveredWorkflow.exportFilePath,
+				resolvedFilePath: discoveredWorkflow.resolvedFilePath,
+				exportName: discoveredWorkflow.exportName,
+				localExportName: discoveredWorkflow.localExportName,
+				taskId: manifestData.id,
+				taskName: manifestData.name
+			},
+			manifest: manifestData,
+			bundle: {
+				code: bundle.code,
+				sourceMap: bundle.sourceMap,
+				localDependencies: bundle.localDependencies,
+				externalImports: bundle.externalImports,
+				size: bundle.size
+			},
+			triggers: triggerResult.artifacts,
+			timing: {
+				importMs: taskMetadata.timing.importMs,
+				manifestMs: taskMetadata.timing.manifestMs,
+				bundleMs,
+				triggerMs,
+				totalMs: performance.now() - totalStartedAt
+			}
+		},
+		triggerFailures: triggerResult.failures
+	};
+}
+async function buildTaskArtifacts(options) {
+	const taskArtifacts = [];
+	const failures = [];
+	for (const entry of options.entries) try {
+		const result = await buildTaskArtifact({
+			discoveredWorkflow: entry.discoveredWorkflow,
+			taskMetadata: entry.taskMetadata,
+			projectRoot: options.projectRoot,
+			sourceMaps: options.sourceMaps
+		});
+		taskArtifacts.push(result.artifact);
+		failures.push(...result.triggerFailures);
+	} catch (error) {
+		failures.push({
+			kind: "task",
+			task: {
+				bindingKey: entry.discoveredWorkflow.bindingKey,
+				exportFilePath: entry.discoveredWorkflow.exportFilePath,
+				resolvedFilePath: entry.discoveredWorkflow.resolvedFilePath,
+				exportName: entry.discoveredWorkflow.exportName,
+				localExportName: entry.discoveredWorkflow.localExportName,
+				taskId: entry.discoveredWorkflow.exportName,
+				taskName: entry.discoveredWorkflow.exportName
+			},
+			phase: "bundle",
+			error: `Task bundle failed: ${error instanceof Error ? error.message : String(error)}`
+		});
+	}
+	return {
+		taskArtifacts,
+		failures
+	};
+}
+//#endregion
+export { buildTaskArtifacts };

package/dist/build-workflows-CfxBnIWh-CdYPv8w2.mjs

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+
+import { _ as deduplicateCredentialRequirementEntries } from "./schedule-BXx3uXwr.mjs";
+import { i as WORKFLOW_MANIFEST_GENERATOR, s as WorkflowManifestSchema } from "./_manifest-JSRE3H8k.mjs";
+import { a as MANIFEST_FILE_NAME, i as FLOW_FILE_NAME, r as BUNDLE_FILE_NAME, s as SOURCE_MAP_FILE_NAME, t as BUILD_DIR_NAME } from "./layout-CbMtQ2tm.mjs";
+import { t as runWithConcurrency } from "./concurrency-gXn9Rw8x-DNl2YtrS.mjs";
+import { n as WorkflowLoaderProtocolError, r as WorkflowMetadataLoadError, s as createLoaderProtocolFailure } from "./import-module-CV84H5fZ-B_CBCmb4.mjs";
+import { r as toRelativeFilePath } from "./normalize-path-CojS-CgQ-DLCOvnD1.mjs";
+import { n as bundleWorkflowTarget } from "./workflow-bundler-BPiqVscj-X1PFFAuP.mjs";
+import { t as buildTriggerArtifacts } from "./trigger-artifacts-DQPbQNqC-B4yeeFBY.mjs";
+import { realpathSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import * as path$1 from "node:path";
+import { createHash } from "node:crypto";
+import { performance } from "node:perf_hooks";
+//#region ../../packages/workflow-builder/dist/build-workflows-CfxBnIWh.mjs
+/**
+* Resolves and categorizes all dependencies for a workflow manifest.
+* - Local files: relative paths with SHA256 content hashes
+* - npm packages: package name -> declared version
+* - Workspace packages: @keystroke/* -> version specifier
+* - Builtins: node:* specifiers
+*/
+async function resolveDependencies(options) {
+	const { projectRoot, localDependencies, externalImports } = options;
+	const localFiles = {};
+	await Promise.all(localDependencies.map(async (absPath) => {
+		const relPath = path$1.relative(projectRoot, absPath);
+		try {
+			const content = await readFile(absPath);
+			localFiles[relPath] = createHash("sha256").update(content).digest("hex");
+		} catch {
+			localFiles[relPath] = "unknown";
+		}
+	}));
+	const builtins = [];
+	const packageSpecifiers = [];
+	for (const specifier of externalImports) if (specifier.startsWith("node:")) builtins.push(specifier);
+	else packageSpecifiers.push(specifier);
+	const packageVersions = options.packageVersionCache ?? await readPackageVersions(projectRoot);
+	const packages = {};
+	const workspacePackages = {};
+	for (const specifier of packageSpecifiers) {
+		const packageName = extractPackageName(specifier);
+		const version = packageVersions.get(packageName);
+		if (specifier.startsWith("@keystroke/")) workspacePackages[packageName] = version ?? "workspace:*";
+		else packages[packageName] = version ?? "unknown";
+	}
+	return {
+		localFiles: sortRecord(localFiles),
+		packages: sortRecord(packages),
+		workspacePackages: sortRecord(workspacePackages),
+		builtins: builtins.sort()
+	};
+}
+/**
+* Extracts the npm package name from a module specifier.
+* Handles scoped packages: `@scope/pkg/subpath` -> `@scope/pkg`
+* Handles regular packages: `lodash/fp` -> `lodash`
+*/
+function extractPackageName(specifier) {
+	if (specifier.startsWith("@")) {
+		const [scope, name] = specifier.split("/");
+		if (scope && name) return `${scope}/${name}`;
+		return specifier;
+	}
+	const [name] = specifier.split("/");
+	return name ?? specifier;
+}
+/**
+* Reads package.json files starting from projectRoot and walking up to find
+* all declared dependency versions. Merges dependencies and devDependencies.
+*/
+async function readPackageVersions(projectRoot) {
+	const versions = /* @__PURE__ */ new Map();
+	let currentDir = path$1.resolve(projectRoot);
+	while (true) {
+		const candidate = path$1.join(currentDir, "package.json");
+		try {
+			const content = await readFile(candidate, "utf8");
+			const pkg = JSON.parse(content);
+			if (pkg.dependencies) {
+				for (const [name, version] of Object.entries(pkg.dependencies)) if (!versions.has(name)) versions.set(name, version);
+			}
+			if (pkg.devDependencies) {
+				for (const [name, version] of Object.entries(pkg.devDependencies)) if (!versions.has(name)) versions.set(name, version);
+			}
+		} catch {}
+		const parentDir = path$1.dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	return versions;
+}
+function sortRecord(record) {
+	return Object.fromEntries(Object.entries(record).sort(([a], [b]) => a.localeCompare(b)));
+}
+function resolveBundleConcurrencyLimit() {
+	const raw = process.env.KEYSTROKE_WORKFLOW_BUNDLE_CONCURRENCY?.trim();
+	if (!raw) return Number.POSITIVE_INFINITY;
+	const parsed = Number.parseInt(raw, 10);
+	if (!Number.isFinite(parsed) || parsed < 1) return Number.POSITIVE_INFINITY;
+	return parsed;
+}
+function createWorkflowMetadataFailure(discoveredWorkflow, error) {
+	const message = error instanceof Error ? error.message : "No metadata loaded";
+	return error instanceof WorkflowMetadataLoadError ? {
+		kind: "workflow",
+		workflow: discoveredWorkflow,
+		phase: error.phase,
+		error: message
+	} : error instanceof WorkflowLoaderProtocolError ? createLoaderProtocolFailure(discoveredWorkflow, error.source, message, error.rawOutput) : {
+		kind: "workflow",
+		workflow: discoveredWorkflow,
+		phase: "import",
+		error: message
+	};
+}
+async function buildWorkflowArtifacts(options) {
+	const artifacts = [];
+	const failures = [];
+	const warnings = [];
+	const packageVersionCache = await readPackageVersions(options.projectRoot);
+	const workflowDelegateRegistry = buildWorkflowDelegateRegistry({
+		workflowsByKey: options.workflowsByKey,
+		metadataByKey: options.metadataByKey
+	});
+	const bundleJobs = options.entries.map((entry) => async () => {
+		const { discoveredWorkflow, metadata, workflowIndex } = entry;
+		const totalStartedAt = performance.now();
+		options.onProgressEvent?.({
+			phase: "workflow-stage",
+			stage: "start",
+			workflow: discoveredWorkflow,
+			workflowIndex,
+			workflowCount: options.workflowCount,
+			elapsedMs: 0
+		});
+		try {
+			const { manifest: loadedManifest, flowGraph, triggers: sameFileTriggers, credentialsByCallsiteFingerprint, credentialAttributionWarnings, timing } = metadata;
+			const nestingErrors = flowGraph.diagnostics?.filter((d) => d.startsWith("[nesting-error]"));
+			if (nestingErrors && nestingErrors.length > 0) {
+				for (const nestingError of nestingErrors) failures.push({
+					kind: "workflow",
+					workflow: discoveredWorkflow,
+					phase: "flow-graph",
+					error: nestingError.replace("[nesting-error] ", "")
+				});
+				return;
+			}
+			warnings.push(...credentialAttributionWarnings.map((warning) => `${discoveredWorkflow.resolvedFilePath}: [${warning.category}] Could not match declared credential requirements for "${warning.bindingName}" (${warning.credentialSetIds.join(", ")}) to a static callsite fingerprint.`));
+			const bundle = await bundleWorkflowTarget({
+				filePath: discoveredWorkflow.resolvedFilePath,
+				localExportName: discoveredWorkflow.localExportName,
+				projectRoot: options.projectRoot,
+				delegateRegistry: workflowDelegateRegistry,
+				sourceMap: options.sourceMaps
+			});
+			const bundleMs = performance.now() - totalStartedAt - timing.importMs;
+			const manifest = await finalizeWorkflowManifest({
+				coreManifest: loadedManifest,
+				flowGraph,
+				exportName: discoveredWorkflow.exportName,
+				workflowFilePath: discoveredWorkflow.resolvedFilePath,
+				bundle,
+				credentialsByCallsiteFingerprint,
+				projectRoot: options.projectRoot,
+				packageVersionCache
+			});
+			const triggerStartedAt = performance.now();
+			const triggerResult = await buildTriggerArtifacts(sameFileTriggers, manifest.id, manifest.name, options.projectRoot, {
+				workflowExportName: discoveredWorkflow.localExportName,
+				workflowFilePath: discoveredWorkflow.resolvedFilePath
+			});
+			failures.push(...triggerResult.failures);
+			const triggerMs = performance.now() - triggerStartedAt;
+			const artifact = {
+				workflow: {
+					...discoveredWorkflow,
+					workflowId: manifest.id
+				},
+				manifest,
+				flowGraph,
+				bundle,
+				triggers: triggerResult.artifacts,
+				timing: {
+					importMs: timing.importMs,
+					manifestMs: timing.manifestMs,
+					flowGraphMs: timing.flowGraphMs,
+					bundleMs,
+					triggerMs,
+					totalMs: performance.now() - totalStartedAt
+				}
+			};
+			artifacts.push(artifact);
+			options.onProgressEvent?.({
+				phase: "workflow-stage",
+				stage: "success",
+				workflow: artifact.workflow,
+				workflowIndex,
+				workflowCount: options.workflowCount,
+				elapsedMs: artifact.timing.totalMs
+			});
+		} catch (error) {
+			const failure = {
+				kind: "workflow",
+				workflow: discoveredWorkflow,
+				phase: "bundle",
+				error: error instanceof Error ? error.message : String(error)
+			};
+			failures.push(failure);
+			options.onProgressEvent?.({
+				phase: "workflow-stage",
+				stage: "failure",
+				workflow: discoveredWorkflow,
+				workflowIndex,
+				workflowCount: options.workflowCount,
+				elapsedMs: 0,
+				failure
+			});
+		}
+	});
+	const bundleLimit = resolveBundleConcurrencyLimit();
+	const effectiveBundleConcurrency = Number.isFinite(bundleLimit) ? Math.min(bundleLimit, bundleJobs.length) : bundleJobs.length;
+	await runWithConcurrency(bundleJobs, Math.max(1, effectiveBundleConcurrency), (job) => job());
+	return {
+		artifacts,
+		failures,
+		warnings
+	};
+}
+/** @internal Exported for tests. */
+function buildCredentialRequirements(flowGraph, credentialsByCallsiteFingerprint) {
+	const byStep = {};
+	const allCredentialSetIds = /* @__PURE__ */ new Set();
+	const toCredentialRequirementEntries = (entries) => entries.map((entry) => ({
+		credentialSetId: entry.resolvedCredentialSetId,
+		credentialKeys: entry.credentialKeys,
+		...entry.optionalCredentialKeys && entry.optionalCredentialKeys.length > 0 ? { optionalCredentialKeys: entry.optionalCredentialKeys } : {},
+		...entry.storedCredentialKeys && entry.storedCredentialKeys.length > 0 ? { storedCredentialKeys: entry.storedCredentialKeys } : {},
+		...entry.optionalStoredCredentialKeys && entry.optionalStoredCredentialKeys.length > 0 ? { optionalStoredCredentialKeys: entry.optionalStoredCredentialKeys } : {},
+		...entry.schemaFingerprint ? { schemaFingerprint: entry.schemaFingerprint } : {},
+		...entry.proxy ? { proxy: entry.proxy } : {},
+		...entry.needsRawSecret === true ? { needsRawSecret: true } : {},
+		...entry.needsResolve === true ? { needsResolve: true } : {},
+		...typeof entry.resolveCacheMs === "number" && entry.resolveCacheMs > 0 ? { resolveCacheMs: entry.resolveCacheMs } : {},
+		...entry.onCredentialRevoked ? { onCredentialRevoked: entry.onCredentialRevoked } : {},
+		...entry.requiredOAuthScopes?.length ? { requiredOAuthScopes: entry.requiredOAuthScopes } : {}
+	}));
+	for (const node of flowGraph.nodes) {
+		if (node.type !== "step" || node.data.kind !== "call") continue;
+		const operationScopes = "requiredOAuthScopes" in node.data && node.data.requiredOAuthScopes?.length ? node.data.requiredOAuthScopes : void 0;
+		const nodeEntries = node.data.credentialSets?.map((entry) => ({
+			credentialSetId: entry.resolvedId,
+			credentialKeys: entry.credentialKeys,
+			...entry.optionalCredentialKeys && entry.optionalCredentialKeys.length > 0 ? { optionalCredentialKeys: entry.optionalCredentialKeys } : {},
+			...entry.storedCredentialKeys && entry.storedCredentialKeys.length > 0 ? { storedCredentialKeys: entry.storedCredentialKeys } : {},
+			...entry.optionalStoredCredentialKeys && entry.optionalStoredCredentialKeys.length > 0 ? { optionalStoredCredentialKeys: entry.optionalStoredCredentialKeys } : {},
+			...entry.schemaFingerprint ? { schemaFingerprint: entry.schemaFingerprint } : {},
+			...entry.proxy ? { proxy: entry.proxy } : {},
+			...entry.needsRawSecret === true ? { needsRawSecret: true } : {},
+			...entry.needsResolve === true ? { needsResolve: true } : {},
+			...typeof entry.resolveCacheMs === "number" && entry.resolveCacheMs > 0 ? { resolveCacheMs: entry.resolveCacheMs } : {},
+			...entry.onCredentialRevoked ? { onCredentialRevoked: entry.onCredentialRevoked } : {},
+			...operationScopes ? { requiredOAuthScopes: [...operationScopes] } : {}
+		})) ?? [];
+		const callsiteEntries = node.data.callsiteFingerprint ? toCredentialRequirementEntries(credentialsByCallsiteFingerprint[node.data.callsiteFingerprint] ?? []) : [];
+		const entries = deduplicateCredentialRequirementEntries([...nodeEntries, ...callsiteEntries]);
+		if (entries.length === 0) continue;
+		byStep[node.id] = entries;
+		for (const entry of entries) allCredentialSetIds.add(entry.credentialSetId);
+	}
+	if (allCredentialSetIds.size === 0) return void 0;
+	return {
+		required: [...allCredentialSetIds].sort(),
+		byStep
+	};
+}
+function extractStepsFromFlowGraph(flowGraph) {
+	const steps = {};
+	for (const node of flowGraph.nodes) if (node.type === "step" && node.data.kind === "call") steps[node.id] = {
+		nodeId: node.id,
+		stepName: node.data.stepName,
+		label: node.label,
+		callKind: node.data.callKind,
+		...node.data.exportName ? { exportName: node.data.exportName } : {},
+		...node.data.stepId ? { stepId: node.data.stepId } : {},
+		...node.data.source ? { source: node.data.source } : {},
+		...node.data.astKind ? { astKind: node.data.astKind } : {},
+		...node.data.importSource ? { importSource: node.data.importSource } : {},
+		...node.data.outputBinding ? { outputBinding: node.data.outputBinding } : {},
+		...node.data.scopeOverride ? { scopeOverride: node.data.scopeOverride } : {},
+		...node.data.description ? { description: node.data.description } : {},
+		...node.data.inputSchema ? { inputSchema: node.data.inputSchema } : {},
+		...node.data.outputSchema ? { outputSchema: node.data.outputSchema } : {},
+		..."credentialSets" in node.data && node.data.credentialSets ? { credentialSets: node.data.credentialSets } : {}
+	};
+	return steps;
+}
+async function finalizeWorkflowManifest(options) {
+	const credentials = buildCredentialRequirements(options.flowGraph, options.credentialsByCallsiteFingerprint);
+	const workflowSourceFilePath = toRelativeFilePath(options.projectRoot, options.workflowFilePath);
+	const dependencies = await resolveDependencies({
+		projectRoot: options.projectRoot,
+		localDependencies: options.bundle.localDependencies,
+		externalImports: options.bundle.externalImports,
+		packageVersionCache: options.packageVersionCache
+	});
+	return WorkflowManifestSchema.parse({
+		...options.coreManifest,
+		exportName: options.exportName,
+		workflowSource: {
+			filePath: workflowSourceFilePath,
+			line: 1,
+			column: 1,
+			endLine: 1,
+			endColumn: 1,
+			synthetic: true
+		},
+		dependencies,
+		steps: extractStepsFromFlowGraph(options.flowGraph),
+		...credentials ? { credentials } : {},
+		buildInfo: {
+			...options.coreManifest.buildInfo,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			builderVersion: "workflow-builder",
+			generatedBy: WORKFLOW_MANIFEST_GENERATOR,
+			nodeVersion: process.version,
+			platform: process.platform,
+			sourceChecksumAlgorithm: "sha256",
+			sourceChecksum: "0".repeat(64),
+			generatedFiles: [
+				MANIFEST_FILE_NAME,
+				FLOW_FILE_NAME,
+				`${BUILD_DIR_NAME}/${BUNDLE_FILE_NAME}`,
+				...options.bundle.sourceMap ? [`${BUILD_DIR_NAME}/${SOURCE_MAP_FILE_NAME}`] : []
+			]
+		}
+	});
+}
+function buildWorkflowDelegateRegistry(options) {
+	const registry = {};
+	for (const [bindingKey, { workflow }] of options.workflowsByKey) {
+		const metadata = options.metadataByKey.get(bindingKey);
+		if (!metadata?.ok) continue;
+		const entry = "agentMetadata" in metadata ? {
+			exportName: workflow.localExportName,
+			kind: "agent",
+			authoredId: typeof metadata.agentMetadata.manifest.authoredAgentId === "string" ? metadata.agentMetadata.manifest.authoredAgentId : typeof metadata.agentMetadata.manifest.id === "string" ? metadata.agentMetadata.manifest.id : workflow.exportName,
+			displayName: typeof metadata.agentMetadata.manifest.name === "string" ? metadata.agentMetadata.manifest.name : workflow.exportName
+		} : "taskMetadata" in metadata ? {
+			exportName: workflow.localExportName,
+			kind: "task",
+			authoredId: metadata.taskMetadata.manifest.id,
+			displayName: metadata.taskMetadata.manifest.name
+		} : {
+			exportName: workflow.localExportName,
+			kind: "workflow",
+			authoredId: metadata.metadata.manifest.id,
+			displayName: metadata.metadata.manifest.name
+		};
+		const resolvedFilePath = realpathSync.native(workflow.resolvedFilePath);
+		const existing = registry[resolvedFilePath] ?? [];
+		existing.push(entry);
+		registry[resolvedFilePath] = existing;
+	}
+	return registry;
+}
+//#endregion
+export { buildWorkflowArtifacts, createWorkflowMetadataFailure };

package/dist/build.handler-4799CjWH.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+import { C as CliExitError } from "./keystroke.mjs";
+import { d as trackProject } from "./dist-CUK7yBM0.mjs";
+import { t as requireWorkflowsDir } from "./resolve-project-DDJ29sCF.mjs";
+import { a as runWorkflowBuild, i as renderBuildSummary, n as renderBuildFailure, r as renderBuildHeader } from "./workflow-build-DBQaBfnn.mjs";
+import { t as createBuildProgress } from "./build-progress-DgYKb4hB.mjs";
+import { t as withErrorBoundary } from "./error-boundary-VL-JLfIa.mjs";
+//#region src/commands/workflows/build.handler.ts
+async function handleWorkflowsBuild(options, _ctx) {
+	return withErrorBoundary("Build", async () => {
+		const workflowsDir = await requireWorkflowsDir(options.path);
+		trackProject(workflowsDir);
+		renderBuildHeader(options.name);
+		const progress = createBuildProgress(options.name ?? "workflow");
+		try {
+			const { result, outDir } = await runWorkflowBuild({
+				workflowsDir,
+				verbose: options.verbose,
+				name: options.name,
+				force: options.force,
+				targetFiles: options.target,
+				...options.disableSourcemaps ? { sourceMaps: false } : {},
+				onProgressEvent: progress.handleEvent
+			});
+			renderBuildSummary(result, outDir);
+		} catch (error) {
+			renderBuildFailure(error);
+			throw new CliExitError("Build failed");
+		} finally {
+			progress.stop();
+		}
+	});
+}
+//#endregion
+export { handleWorkflowsBuild };