@keystrokehq/cli 0.0.1

package/dist/dist-BkJUoBiG.mjs

@@ -0,0 +1,1116 @@
+#!/usr/bin/env node
+
+import { n as __exportAll } from "./chunk-CH6r78ws.mjs";
+import { t as assertWorkflowProjectRoot } from "./project-config-D1qsQlO7.mjs";
+import { V as SHA256HashSchema, g as collectCredentialRequirementEntries, p as TriggerUploadDataSchema } from "./schedule-BXx3uXwr.mjs";
+import { c as FlowGraphSchema, s as WorkflowManifestSchema } from "./_manifest-JSRE3H8k.mjs";
+import { t as AgentVersionManifestSchema } from "./agent-manifest-CDnbkR2f.mjs";
+import { t as TaskBuildManifestSchema } from "./schemas-CDib1RhE.mjs";
+import "./task-B2sZMaZu.mjs";
+import { n as FileMetadataSchema } from "./file-metadata-D1vm-XY2.mjs";
+import { t as computeProjectSnapshotHash } from "./task-target-deploy-CA6elFpF-BEr4gkol.mjs";
+import { a as MANIFEST_FILE_NAME, d as getMetadataRoot, f as getTriggersDir, m as getWorkflowManifestPath, p as getWorkflowArtifactPaths, t as BUILD_DIR_NAME } from "./layout-CbMtQ2tm.mjs";
+import { n as resolveProjectBuildOutputDir } from "./utils-CywxCDM7.mjs";
+import { t as TriggerBuildManifestSchema } from "./trigger-manifest-CY7brZeg.mjs";
+import { t as batchUpload } from "./upload-CkU--iDC.mjs";
+import { createReadStream } from "node:fs";
+import * as fs from "node:fs/promises";
+import { stat } from "node:fs/promises";
+import * as path$1 from "node:path";
+import path from "node:path";
+import { createHash } from "node:crypto";
+//#region ../../packages/workflow-deploy/dist/index.mjs
+var dist_exports = /* @__PURE__ */ __exportAll({
+	collectCredentialFingerprintMapFromProjectDist: () => collectCredentialFingerprintMapFromProjectDist,
+	collectSchemaFingerprintsFromAgentManifest: () => collectSchemaFingerprintsFromAgentManifest,
+	deployFromDir: () => deployFromDir,
+	readAgentManifestsFromOutDir: () => readAgentManifestsFromOutDir,
+	readManifestsFromOutDir: () => readManifestsFromOutDir,
+	readWorkflowsFromDisk: () => readWorkflowsFromDisk,
+	uploadTestBundle: () => uploadTestBundle
+});
+/** Matches `AGENT_ARTIFACT_DIR_PREFIX` in `@keystroke/workflow-builder` artifact layout. */
+const AGENT_ARTIFACT_DIR_PREFIX$1 = "agent_";
+/**
+* Reads all workflow manifests from the dist output directory.
+* Optionally filters by workflow ref: tries authored id first, then name.
+*
+* When ref is provided:
+* - First match: manifest.id === ref
+* - Fallback: manifest.name === ref
+*
+* Returns [] when the dist directory does not exist or is unreadable.
+*/
+async function readManifestsFromOutDir(workflowsDir, ref) {
+	const distDir = await resolveProjectBuildOutputDir(workflowsDir);
+	const entries = await fs.readdir(distDir, { withFileTypes: true }).catch(() => null);
+	if (!entries) return [];
+	const byId = [];
+	const byName = [];
+	const all = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const manifestPath = getWorkflowManifestPath(distDir, entry.name);
+		try {
+			const raw = await fs.readFile(manifestPath, "utf-8");
+			const parsed = WorkflowManifestSchema.safeParse(JSON.parse(raw));
+			if (!parsed.success) continue;
+			if (ref === void 0) {
+				all.push({
+					manifest: parsed.data,
+					manifestPath
+				});
+				continue;
+			}
+			if (parsed.data.id === ref) byId.push({
+				manifest: parsed.data,
+				manifestPath
+			});
+			else if (parsed.data.name === ref) byName.push({
+				manifest: parsed.data,
+				manifestPath
+			});
+		} catch {}
+	}
+	if (ref === void 0) return all;
+	if (byId.length > 0) return byId;
+	return byName;
+}
+/**
+* Reads all built agent version manifests from the dist output directory.
+* Agent artifacts live under `dist/agent_<authoredAgentId>_<hash>/manifest.json`.
+*
+* Returns [] when the dist directory does not exist or is unreadable.
+*/
+async function readAgentManifestsFromOutDir(workflowsDir) {
+	const distDir = await resolveProjectBuildOutputDir(workflowsDir);
+	const entries = await fs.readdir(distDir, { withFileTypes: true }).catch(() => null);
+	if (!entries) return [];
+	const results = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory() || !entry.name.startsWith(AGENT_ARTIFACT_DIR_PREFIX$1)) continue;
+		const manifestPath = path.join(distDir, entry.name, MANIFEST_FILE_NAME);
+		try {
+			const raw = await fs.readFile(manifestPath, "utf-8");
+			const parsed = AgentVersionManifestSchema.safeParse(JSON.parse(raw));
+			if (!parsed.success) continue;
+			results.push({
+				manifest: parsed.data,
+				manifestPath
+			});
+		} catch {}
+	}
+	return results;
+}
+/**
+* Collects `resolvedCredentialSetId` → `schemaFingerprint` from a built agent
+* manifest (top-level credential sets, MCP servers, and messaging gateways).
+*/
+function collectSchemaFingerprintsFromAgentManifest(manifest) {
+	const map = /* @__PURE__ */ new Map();
+	const put = (resolvedId, fingerprint) => {
+		if (fingerprint && !map.has(resolvedId)) map.set(resolvedId, fingerprint);
+	};
+	for (const credentialSet of manifest.credentialSets ?? []) put(credentialSet.resolvedId, credentialSet.schemaFingerprint);
+	for (const server of manifest.mcpServers ?? []) for (const credentialSet of server.credentialSets) put(credentialSet.resolvedId, credentialSet.schemaFingerprint);
+	for (const gateway of manifest.messaging ?? []) put(gateway.credentialSet.resolvedId, gateway.credentialSet.schemaFingerprint);
+	return map;
+}
+/**
+* Builds `resolvedCredentialSetId` → `schemaFingerprint` from all workflow
+* manifests and agent version manifests under a project's build output dir.
+*/
+async function collectCredentialFingerprintMapFromProjectDist(projectRoot) {
+	const map = /* @__PURE__ */ new Map();
+	for (const { manifest } of await readManifestsFromOutDir(projectRoot)) for (const entry of collectCredentialRequirementEntries(manifest.credentials)) if (entry.schemaFingerprint && !map.has(entry.credentialSetId)) map.set(entry.credentialSetId, entry.schemaFingerprint);
+	for (const { manifest } of await readAgentManifestsFromOutDir(projectRoot)) for (const [resolvedId, fp] of collectSchemaFingerprintsFromAgentManifest(manifest)) if (!map.has(resolvedId)) map.set(resolvedId, fp);
+	return map;
+}
+function splitChangedArtifacts(options) {
+	if (options.force) return {
+		toUpload: options.prepared,
+		skippedResults: []
+	};
+	const toUpload = [];
+	const skippedResults = [];
+	for (const item of options.prepared) {
+		const name = options.getName(item);
+		if (options.existingArtifacts[name]?.bundleHash === options.getHash(item)) {
+			skippedResults.push(options.toSkippedResult(name));
+			continue;
+		}
+		toUpload.push(item);
+	}
+	return {
+		toUpload,
+		skippedResults
+	};
+}
+/** Separates unchanged workflows (skipped) from those needing upload. */
+function filterUnchangedWorkflows(prepared, existingArtifacts, force) {
+	const { toUpload, skippedResults } = splitChangedArtifacts({
+		prepared,
+		existingArtifacts,
+		force,
+		getName: (workflow) => workflow.name,
+		getHash: (workflow) => workflow.bundleHash,
+		toSkippedResult: (name) => ({
+			name,
+			status: "skipped"
+		})
+	});
+	return {
+		workflowsToUpload: toUpload,
+		skippedResults
+	};
+}
+/** Separates unchanged agents (skipped) from those needing upload. */
+function filterUnchangedAgents(prepared, existingArtifacts, force) {
+	const { toUpload, skippedResults } = splitChangedArtifacts({
+		prepared,
+		existingArtifacts,
+		force,
+		getName: (agent) => agent.agentId,
+		getHash: (agent) => agent.sandboxPackageHash,
+		toSkippedResult: (name) => ({
+			name,
+			status: "skipped"
+		})
+	});
+	return {
+		agentsToUpload: toUpload,
+		skippedResults
+	};
+}
+/** Separates unchanged tasks (skipped) from those needing upload. */
+function filterUnchangedTasks(prepared, existingArtifacts, force) {
+	const { toUpload, skippedResults } = splitChangedArtifacts({
+		prepared,
+		existingArtifacts,
+		force,
+		getName: (task) => task.taskId,
+		getHash: (task) => task.bundleHash,
+		toSkippedResult: (name) => ({
+			name,
+			status: "skipped"
+		})
+	});
+	return {
+		tasksToUpload: toUpload,
+		skippedResults
+	};
+}
+const EMPTY_RESULT = {
+	workflowArtifacts: {},
+	agentArtifacts: {},
+	taskArtifacts: {},
+	workflowFilter: {
+		workflowsToUpload: [],
+		skippedResults: []
+	},
+	agentFilter: {
+		agentsToUpload: [],
+		skippedResults: []
+	},
+	taskFilter: {
+		tasksToUpload: [],
+		skippedResults: []
+	}
+};
+async function hashCheckAndFilter(options) {
+	const { prepared, preparedAgents, preparedTasks, client, organizationId, projectId, force, onDeployProgressEvent } = options;
+	if (prepared.length === 0 && preparedAgents.length === 0 && preparedTasks.length === 0) return EMPTY_RESULT;
+	const hashCheckStartTime = Date.now();
+	onDeployProgressEvent?.({
+		phase: "hash-check",
+		status: "start",
+		workflowCount: prepared.length,
+		agentCount: preparedAgents.length,
+		taskCount: preparedTasks.length
+	});
+	const hashLookup = await client.bundles.getHashes({
+		organizationId,
+		projectId,
+		...prepared.length > 0 ? { workflowNames: prepared.map((workflow) => workflow.name) } : {},
+		...preparedAgents.length > 0 ? { agentIds: preparedAgents.map((agent) => agent.agentId) } : {},
+		...preparedTasks.length > 0 ? { tasks: preparedTasks.map((task) => ({
+			taskId: task.taskId,
+			bundleHash: task.bundleHash
+		})) } : {}
+	});
+	onDeployProgressEvent?.({
+		phase: "hash-check",
+		status: "complete",
+		elapsedMs: Date.now() - hashCheckStartTime
+	});
+	const filterStartTime = Date.now();
+	const workflowFilter = filterUnchangedWorkflows(prepared, hashLookup.workflows, force);
+	const agentFilter = filterUnchangedAgents(preparedAgents, hashLookup.agents, force);
+	const taskFilter = filterUnchangedTasks(preparedTasks, hashLookup.tasks || {}, force);
+	onDeployProgressEvent?.({
+		phase: "filter",
+		status: "complete",
+		workflowsToUpload: workflowFilter.workflowsToUpload.length,
+		workflowsSkipped: workflowFilter.skippedResults.length,
+		agentsToUpload: agentFilter.agentsToUpload.length,
+		agentsSkipped: agentFilter.skippedResults.length,
+		tasksToUpload: taskFilter.tasksToUpload.length,
+		tasksSkipped: taskFilter.skippedResults.length,
+		force,
+		elapsedMs: Date.now() - filterStartTime
+	});
+	return {
+		workflowArtifacts: hashLookup.workflows,
+		agentArtifacts: hashLookup.agents,
+		taskArtifacts: hashLookup.tasks || {},
+		workflowFilter,
+		agentFilter,
+		taskFilter
+	};
+}
+function finalizeDeployResult(options) {
+	const result = {
+		success: options.workflows.every((workflow) => workflow.status !== "failed") && options.agents.every((agent) => agent.status !== "failed") && (options.tasks || []).every((task) => task.status !== "failed"),
+		workflows: options.workflows,
+		agents: options.agents,
+		tasks: options.tasks || [],
+		totalTime: Date.now() - options.startTime
+	};
+	options.onDeployProgressEvent?.({
+		phase: "complete",
+		status: "complete",
+		success: result.success,
+		workflowsTotal: result.workflows.length,
+		agentsTotal: result.agents.length,
+		tasksTotal: result.tasks.length,
+		elapsedMs: result.totalTime
+	});
+	return result;
+}
+async function runUploadPhase(options) {
+	if (options.count === 0) return [];
+	const uploadStartTime = Date.now();
+	options.onDeployProgressEvent?.({
+		phase: options.phase,
+		status: "start",
+		count: options.count,
+		concurrency: options.concurrency
+	});
+	const results = await options.upload();
+	let succeeded = 0;
+	let failed = 0;
+	for (const result of results) {
+		if (result.kind === "success") {
+			succeeded += 1;
+			options.onDeployProgressEvent?.({
+				phase: options.phase,
+				status: "item",
+				name: result.name,
+				result: "success"
+			});
+			continue;
+		}
+		failed += 1;
+		options.onDeployProgressEvent?.({
+			phase: options.phase,
+			status: "item",
+			name: result.name,
+			result: "failure",
+			error: result.error
+		});
+	}
+	options.onDeployProgressEvent?.({
+		phase: options.phase,
+		status: "complete",
+		succeeded,
+		failed,
+		elapsedMs: Date.now() - uploadStartTime
+	});
+	return results;
+}
+function toFailedUploadResults(uploadResults) {
+	return uploadResults.filter((result) => result.kind === "failure").map((result) => ({
+		name: result.name,
+		status: "failed",
+		error: result.error
+	}));
+}
+/** Builds a bundle registration item from a prepared workflow and its upload storage path. */
+function buildBundleRegistrationItem(wf, storagePath, existingArtifacts, force) {
+	return {
+		workflowName: wf.name,
+		storagePath,
+		manifest: { ...wf.manifestData },
+		flowJson: wf.flowData,
+		bundleSize: wf.bundleSize,
+		triggers: wf.triggers,
+		bundleHash: wf.bundleHash,
+		skipVersionBump: !force && existingArtifacts[wf.name]?.bundleHash === wf.bundleHash
+	};
+}
+/** Builds an agent registration item from a prepared agent and its upload storage path. */
+function buildAgentRegistrationItem(agent, storagePath, existingArtifacts, force) {
+	const manifest = {
+		...agent.manifestData,
+		sandbox: {
+			...agent.manifestData.sandbox ?? {},
+			bootstrapArtifacts: [{
+				storagePath,
+				sha256: agent.sandboxPackageHash,
+				target: "/home/user",
+				kind: "archive"
+			}],
+			sandboxBundleStoragePath: storagePath
+		}
+	};
+	return {
+		agentId: agent.agentId,
+		agentName: agent.agentName,
+		storagePath,
+		manifest,
+		bundleSize: agent.sandboxPackageSize,
+		bundleHash: agent.sandboxPackageHash,
+		skipVersionBump: !force && existingArtifacts[agent.agentId]?.bundleHash === agent.sandboxPackageHash
+	};
+}
+/** Builds a task registration item from a prepared task and its upload storage path. */
+function buildTaskRegistrationItem(task, storagePath, existingArtifacts, force) {
+	return {
+		taskId: task.taskId,
+		taskName: task.name,
+		storagePath,
+		manifest: { ...task.manifestData },
+		bundleSize: task.bundleSize,
+		bundleHash: task.bundleHash,
+		triggers: task.triggers,
+		skipVersionBump: !force && existingArtifacts[task.taskId]?.bundleHash === task.bundleHash
+	};
+}
+async function syncProjectFileMetadata(client, organizationId, projectId, fileMetadata) {
+	return client.bundles.syncFileMetadata({
+		fileMetadata,
+		organizationId,
+		projectId,
+		syncMode: "replace"
+	});
+}
+function resolveArtifactStoragePath(uploadedStoragePath, existingArtifact, artifactLabel, artifactName) {
+	const storagePath = uploadedStoragePath ?? existingArtifact?.storagePath;
+	if (!storagePath) throw new Error(`Missing current deployment storage path for unchanged ${artifactLabel} "${artifactName}"`);
+	return storagePath;
+}
+function mapDeployResultStatus(result) {
+	if (result.status === "failed") return {
+		name: result.name,
+		status: "failed",
+		error: result.error
+	};
+	if (result.status === "skipped") return {
+		name: result.name,
+		status: "skipped"
+	};
+	return {
+		name: result.name,
+		status: "deployed",
+		authoredWorkflowId: result.authoredWorkflowId
+	};
+}
+function mapAgentResultStatus(result) {
+	if (result.status === "failed") return {
+		name: result.name,
+		status: "failed",
+		error: result.error
+	};
+	if (result.status === "skipped") return {
+		name: result.name,
+		status: "skipped"
+	};
+	return {
+		name: result.name,
+		status: "deployed",
+		agentId: result.agentId
+	};
+}
+function mapTaskResultStatus(result) {
+	if (result.status === "failed") return {
+		name: result.name,
+		status: "failed",
+		error: result.error
+	};
+	if (result.status === "skipped") return {
+		name: result.name,
+		status: "skipped"
+	};
+	return {
+		name: result.name,
+		status: "deployed",
+		taskId: result.taskId
+	};
+}
+async function registerDeployment(options) {
+	const { prepared, preparedAgents, preparedTasks, successfulWorkflowUploads, successfulAgentUploads, successfulTaskUploads, workflowArtifacts, agentArtifacts, taskArtifacts, organizationId, projectId, projectRoot, client, force, deploymentScope = "project", onDeployProgressEvent } = options;
+	if (prepared.length === 0 && preparedAgents.length === 0 && preparedTasks.length === 0) return {
+		workflows: [],
+		agents: [],
+		tasks: []
+	};
+	const workflowUploadStorageByName = new Map(successfulWorkflowUploads.map((upload) => [upload.name, upload.storagePath]));
+	const agentUploadStorageById = new Map(successfulAgentUploads.map((upload) => [upload.name, upload.storagePath]));
+	const taskUploadStorageById = new Map(successfulTaskUploads.map((upload) => [upload.name, upload.storagePath]));
+	const deploymentStartTime = Date.now();
+	if (prepared.length > 0) onDeployProgressEvent?.({
+		phase: "register-workflows",
+		status: "start",
+		count: prepared.length
+	});
+	if (preparedAgents.length > 0) onDeployProgressEvent?.({
+		phase: "register-agents",
+		status: "start",
+		count: preparedAgents.length
+	});
+	if (preparedTasks.length > 0) onDeployProgressEvent?.({
+		phase: "register-tasks",
+		status: "start",
+		count: preparedTasks.length
+	});
+	const deploymentWorkflows = prepared.map((workflow) => {
+		return buildBundleRegistrationItem(workflow, resolveArtifactStoragePath(workflowUploadStorageByName.get(workflow.name), workflowArtifacts[workflow.name], "workflow", workflow.name), workflowArtifacts, force);
+	});
+	const deploymentAgents = preparedAgents.map((agent) => {
+		return buildAgentRegistrationItem(agent, resolveArtifactStoragePath(agentUploadStorageById.get(agent.agentId), agentArtifacts[agent.agentId], "agent", agent.agentName), agentArtifacts, force);
+	});
+	const deploymentTasks = preparedTasks.map((task) => {
+		return buildTaskRegistrationItem(task, resolveArtifactStoragePath(taskUploadStorageById.get(task.taskId), taskArtifacts[task.taskId], "task", task.name), taskArtifacts, force);
+	});
+	const snapshotHash = computeProjectSnapshotHash({
+		workflows: deploymentWorkflows,
+		agents: deploymentAgents
+	});
+	let deployResult;
+	try {
+		deployResult = await client.public.projects.deploy({
+			organizationId,
+			projectId,
+			projectRoot,
+			scope: deploymentScope,
+			snapshotHash,
+			force,
+			workflows: deploymentWorkflows,
+			agents: deploymentAgents,
+			tasks: deploymentTasks
+		});
+	} finally {
+		releasePreparedTaskCallbackBundleCode(preparedTasks);
+	}
+	const deployedWorkflowResults = deployResult.workflows;
+	const deployedAgentResults = deployResult.agents;
+	const deployedTaskResults = deployResult.tasks ?? [];
+	if (prepared.length > 0) onDeployProgressEvent?.({
+		phase: "register-workflows",
+		status: "complete",
+		succeeded: deployedWorkflowResults.filter((item) => item.status === "deployed").length,
+		failed: deployedWorkflowResults.filter((item) => item.status === "failed").length,
+		elapsedMs: Date.now() - deploymentStartTime
+	});
+	if (preparedAgents.length > 0) onDeployProgressEvent?.({
+		phase: "register-agents",
+		status: "complete",
+		succeeded: deployedAgentResults.filter((item) => item.status === "deployed").length,
+		failed: deployedAgentResults.filter((item) => item.status === "failed").length,
+		elapsedMs: Date.now() - deploymentStartTime
+	});
+	if (preparedTasks.length > 0) onDeployProgressEvent?.({
+		phase: "register-tasks",
+		status: "complete",
+		succeeded: deployedTaskResults.filter((item) => item.status === "deployed").length,
+		failed: deployedTaskResults.filter((item) => item.status === "failed").length,
+		elapsedMs: Date.now() - deploymentStartTime
+	});
+	return {
+		workflows: deployedWorkflowResults.map(mapDeployResultStatus),
+		agents: deployedAgentResults.map(mapAgentResultStatus),
+		tasks: deployedTaskResults.map(mapTaskResultStatus)
+	};
+}
+function releasePreparedTaskCallbackBundleCode(preparedTasks) {
+	for (const task of preparedTasks) for (const trigger of task.triggers) {
+		if (trigger.callbackBundle) trigger.callbackBundle.code = "";
+		if (trigger.transformCallbackBundle) trigger.transformCallbackBundle.code = "";
+	}
+}
+async function syncMetadata(options) {
+	const { client, organizationId, projectId, fileMetadata, onDeployProgressEvent } = options;
+	const metadataSyncStartTime = Date.now();
+	onDeployProgressEvent?.({
+		phase: "sync-file-metadata",
+		status: "start",
+		fileCount: fileMetadata.entries.length
+	});
+	await syncProjectFileMetadata(client, organizationId, projectId, fileMetadata.entries);
+	onDeployProgressEvent?.({
+		phase: "sync-file-metadata",
+		status: "complete",
+		fileCount: fileMetadata.entries.length,
+		elapsedMs: Date.now() - metadataSyncStartTime
+	});
+}
+const AGENT_SANDBOX_PACKAGE_RELATIVE_PATH = `${BUILD_DIR_NAME}/sandbox-bundle.tar.gz`;
+async function hashFile(filePath) {
+	const fileStat = await stat(filePath);
+	const hash = createHash("sha256");
+	await new Promise((resolve, reject) => {
+		const stream = createReadStream(filePath);
+		stream.on("data", (chunk) => hash.update(chunk));
+		stream.on("error", reject);
+		stream.on("end", resolve);
+	});
+	return {
+		hash: hash.digest("hex"),
+		size: fileStat.size
+	};
+}
+/** Top-level build output folder for task bundles; not workflow-shaped (see readTasksFromDisk). */
+const TASKS_OUTPUT_DIR_NAME = "tasks";
+async function readCallbackBundle(baseDir, relativePath) {
+	const bundlePath = path$1.join(baseDir, relativePath);
+	const code = await fs.readFile(bundlePath, "utf-8");
+	return {
+		code,
+		hash: createHash("sha256").update(code).digest("hex"),
+		size: Buffer.byteLength(code)
+	};
+}
+async function readTriggersFromBuildOutput(buildDir, options) {
+	const triggersDir = getTriggersDir(buildDir);
+	try {
+		await fs.access(triggersDir);
+	} catch {
+		return [];
+	}
+	const entries = await fs.readdir(triggersDir, { withFileTypes: true });
+	const triggers = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const triggerDir = path$1.join(triggersDir, entry.name);
+		const manifestPath = path$1.join(triggerDir, MANIFEST_FILE_NAME);
+		try {
+			const raw = await fs.readFile(manifestPath, "utf-8");
+			const manifest = TriggerBuildManifestSchema.parse(JSON.parse(raw));
+			const callbackExports = manifest.functions && Object.keys(manifest.functions).length > 0 ? Object.fromEntries(Object.entries(manifest.functions).map(([key, value]) => [key, value.export])) : void 0;
+			const callbackBundlePath = manifest.functions ? Object.values(manifest.functions)[0]?.js : void 0;
+			const transformCallbackExports = manifest.attachmentFunctions && Object.keys(manifest.attachmentFunctions).length > 0 ? Object.fromEntries(Object.entries(manifest.attachmentFunctions).map(([key, value]) => [key, value.export])) : void 0;
+			const transformCallbackBundlePath = manifest.attachmentFunctions ? Object.values(manifest.attachmentFunctions)[0]?.js : void 0;
+			const trigger = TriggerUploadDataSchema.parse({
+				id: manifest.id,
+				type: manifest.type,
+				...manifest.triggerSource ? { triggerSource: manifest.triggerSource } : {},
+				enabled: manifest.enabled,
+				...manifest.path ? { path: manifest.path } : {},
+				...manifest.method ? { method: manifest.method } : {},
+				...manifest.schedule ? { schedule: manifest.schedule } : {},
+				...manifest.timezone ? { timezone: manifest.timezone } : {},
+				...manifest.config ? { config: manifest.config } : {},
+				...manifest.requiredCredentials ? { requiredCredentials: manifest.requiredCredentials } : {},
+				...callbackExports ? { callbackExports } : {},
+				...callbackBundlePath ? { callbackBundle: await readCallbackBundle(triggerDir, callbackBundlePath) } : {},
+				...transformCallbackExports ? { transformCallbackExports } : {},
+				...transformCallbackBundlePath ? { transformCallbackBundle: await readCallbackBundle(triggerDir, transformCallbackBundlePath) } : {}
+			});
+			triggers.push(trigger);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			options?.onWarning?.(`Skipping trigger artifact ${entry.name}: ${message}`);
+		}
+	}
+	return triggers.sort((left, right) => left.id.localeCompare(right.id));
+}
+/** Reads all workflow artifacts from the build output directory. */
+async function readWorkflowsFromDisk(outDir, options) {
+	const filterSet = options?.filter ? new Set(options.filter) : void 0;
+	let entries;
+	try {
+		entries = await fs.readdir(outDir);
+	} catch {
+		return [];
+	}
+	const workflows = [];
+	for (const entryName of entries) {
+		if (entryName.startsWith("agent_")) continue;
+		if (entryName === "metadata") continue;
+		if (entryName === TASKS_OUTPUT_DIR_NAME) continue;
+		if (!(await fs.stat(path$1.join(outDir, entryName)).catch(() => null))?.isDirectory()) continue;
+		const artifactPaths = getWorkflowArtifactPaths(outDir, entryName);
+		try {
+			const manifestRaw = await fs.readFile(artifactPaths.manifestPath, "utf-8");
+			const manifestData = WorkflowManifestSchema.parse(JSON.parse(manifestRaw));
+			if (filterSet && !filterSet.has(manifestData.name) && !filterSet.has(manifestData.id)) continue;
+			const flowRaw = await fs.readFile(artifactPaths.flowPath, "utf-8");
+			const flowData = FlowGraphSchema.parse(JSON.parse(flowRaw));
+			const bundleInfo = await hashFile(artifactPaths.bundlePath);
+			const bundleHash = SHA256HashSchema.parse(bundleInfo.hash);
+			const triggers = await readTriggersFromBuildOutput(artifactPaths.buildDir, options?.onWarning ? { onWarning: (message) => options.onWarning?.(`[${manifestData.name}] ${message}`) } : void 0);
+			workflows.push({
+				workflowId: entryName,
+				name: manifestData.name,
+				exportName: manifestData.exportName,
+				dependencyPaths: [],
+				bundlePath: artifactPaths.bundlePath,
+				bundleHash,
+				bundleSize: bundleInfo.size,
+				manifestData,
+				flowData,
+				triggers
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			options?.onWarning?.(`Skipping workflow directory ${entryName}: ${message}`);
+		}
+	}
+	return workflows.sort((left, right) => left.name.localeCompare(right.name));
+}
+/** Reads all task artifacts from the build output directory. */
+async function readTasksFromDisk(outDir, options) {
+	const filterSet = options?.filter ? new Set(options.filter) : void 0;
+	const tasksDir = path$1.join(outDir, TASKS_OUTPUT_DIR_NAME);
+	let entries;
+	try {
+		entries = await fs.readdir(tasksDir);
+	} catch {
+		return [];
+	}
+	const tasks = [];
+	for (const entryName of entries) {
+		if (!(await fs.stat(path$1.join(tasksDir, entryName)).catch(() => null))?.isDirectory()) continue;
+		const taskDir = path$1.join(tasksDir, entryName);
+		const manifestPath = path$1.join(taskDir, "manifest.json");
+		const bundlePath = path$1.join(taskDir, "bundle.js");
+		try {
+			const manifestRaw = await fs.readFile(manifestPath, "utf-8");
+			const manifestData = TaskBuildManifestSchema.parse(JSON.parse(manifestRaw));
+			if (filterSet && !filterSet.has(manifestData.name) && !filterSet.has(manifestData.id)) continue;
+			const bundleInfo = await hashFile(bundlePath);
+			const bundleHash = SHA256HashSchema.parse(bundleInfo.hash);
+			const builtTriggers = await readTriggersFromBuildOutput(path$1.join(taskDir, "build"), options);
+			const triggers = builtTriggers.length > 0 ? builtTriggers : manifestData.triggers.map((trigger, index) => {
+				const runtime = trigger.runtime ?? {};
+				const triggerName = trigger.name ?? `trigger_${index}`;
+				const triggerId = createHash("sha256").update(`${entryName}::${triggerName}`).digest("hex").slice(0, 16);
+				const webhookSource = runtime.source && typeof runtime.source === "object" ? runtime.source : null;
+				const sourceType = webhookSource?.type === "app" || webhookSource?.type === "custom" ? webhookSource.type : void 0;
+				return {
+					id: triggerId,
+					type: trigger.triggerType ?? trigger.type,
+					...sourceType ? { triggerSource: sourceType } : {},
+					enabled: trigger.enabled ?? true,
+					...runtime.schedule ? { schedule: runtime.schedule } : {},
+					...runtime.timezone ? { timezone: runtime.timezone } : {},
+					...webhookSource?.path ? { path: webhookSource.path } : {},
+					...webhookSource?.method ? { method: webhookSource.method } : {},
+					...trigger.payload !== void 0 ? { config: { payload: trigger.payload } } : {}
+				};
+			});
+			tasks.push({
+				taskId: entryName,
+				name: manifestData.name,
+				bundlePath,
+				bundleHash,
+				bundleSize: bundleInfo.size,
+				manifestData,
+				triggers
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			options?.onWarning?.(`Skipping task directory ${entryName}: ${message}`);
+		}
+	}
+	return tasks.sort((left, right) => left.name.localeCompare(right.name));
+}
+async function collectJsonFiles(directory) {
+	const entries = await fs.readdir(directory, { withFileTypes: true });
+	return (await Promise.all(entries.map(async (entry) => {
+		const entryPath = path$1.join(directory, entry.name);
+		if (entry.isDirectory()) return collectJsonFiles(entryPath);
+		if (entry.isFile() && entry.name.endsWith(".json")) return [entryPath];
+		return [];
+	}))).flat();
+}
+async function readFileMetadataArtifacts(outDir, options) {
+	const metadataDir = getMetadataRoot(outDir);
+	try {
+		await fs.access(metadataDir);
+	} catch {
+		throw new Error(`Expected file metadata output at ${metadataDir}. Rebuild workflows before deploying.`);
+	}
+	const jsonFiles = await collectJsonFiles(metadataDir);
+	return { entries: (await Promise.all(jsonFiles.map(async (filePath) => {
+		const raw = await fs.readFile(filePath, "utf-8").catch((error) => {
+			throw new Error(`Failed to read file metadata at ${filePath}: ${formatArtifactError(error instanceof Error ? error : String(error))}`);
+		});
+		try {
+			return FileMetadataSchema.parse(JSON.parse(raw));
+		} catch (error) {
+			throw new Error(`Failed to parse file metadata at ${filePath}: ${formatArtifactError(error instanceof Error ? error : String(error))}`);
+		}
+	})).catch((error) => {
+		options?.onWarning?.(error instanceof Error ? error.message : String(error));
+		throw error;
+	})).sort((left, right) => left.filePath.localeCompare(right.filePath)) };
+}
+/**
+* Discovers agent artifacts from the build output directory.
+* Scans outDir/ for agent_* directories containing manifest.json and the
+* packaged sandbox bootstrap archive.
+*/
+async function discoverAgentArtifacts(outDir, options) {
+	const { strict = false, onWarning } = options ?? {};
+	const filterSet = options?.filter ? new Set(options.filter) : void 0;
+	let dirEntries;
+	try {
+		dirEntries = await fs.readdir(outDir);
+	} catch {
+		return [];
+	}
+	const agents = [];
+	for (const entryName of dirEntries) {
+		if (!entryName.startsWith("agent_")) continue;
+		const artifactDir = path$1.join(outDir, entryName);
+		const manifestPath = getWorkflowManifestPath(outDir, entryName);
+		try {
+			const manifestRaw = await fs.readFile(manifestPath, "utf-8").catch((error) => {
+				throw new Error(`Failed to read agent manifest at ${manifestPath}: ${formatArtifactError(error instanceof Error ? error : String(error))}`);
+			});
+			let manifestData;
+			try {
+				manifestData = AgentVersionManifestSchema.parse(JSON.parse(manifestRaw));
+			} catch (error) {
+				throw new Error(`Failed to parse agent manifest at ${manifestPath}: ${formatArtifactError(error instanceof Error ? error : String(error))}`);
+			}
+			if (filterSet && !filterSet.has(manifestData.agentId) && !filterSet.has(manifestData.authoredAgentId) && !filterSet.has(manifestData.agentName)) continue;
+			const sandboxPackagePath = path$1.join(artifactDir, AGENT_SANDBOX_PACKAGE_RELATIVE_PATH);
+			await fs.access(sandboxPackagePath).catch((error) => {
+				throw new Error(`Failed to read agent sandbox package at ${sandboxPackagePath}: ${formatArtifactError(error instanceof Error ? error : String(error))}`);
+			});
+			const sandboxPackageInfo = await hashFile(sandboxPackagePath);
+			const sandboxPackageHash = SHA256HashSchema.parse(sandboxPackageInfo.hash);
+			agents.push({
+				agentId: manifestData.agentId,
+				agentName: manifestData.agentName,
+				sandboxPackagePath,
+				sandboxPackageHash,
+				sandboxPackageSize: sandboxPackageInfo.size,
+				manifestData,
+				sandboxArtifacts: []
+			});
+		} catch (error) {
+			if (strict) throw error;
+			onWarning?.(`Skipping agent artifact ${entryName}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	return agents.sort((left, right) => left.agentName.localeCompare(right.agentName));
+}
+function formatArtifactError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** Uploads a single test bundle, returning the storage path. Throws on failure. */
+async function uploadTestBundle(client, workflow, _localMode) {
+	const { results } = await client.bundles.upload([{
+		workflowName: workflow.name,
+		bundle: workflow.bundle,
+		bundlePath: workflow.bundlePath,
+		bundleHash: workflow.bundleHash,
+		bundleSize: workflow.bundleSize,
+		bundleFileName: path$1.basename(workflow.bundlePath)
+	}], "test");
+	const result = results[0];
+	if (!result || result.kind !== "success") {
+		const error = result?.kind === "failure" ? result.error : "Unknown upload error";
+		throw new Error(`Upload failed for "${workflow.name}": ${error}`);
+	}
+	return { storagePath: result.storagePath };
+}
+/** Uploads bundles to storage (cloud) or resolves local paths. Returns one result per workflow. */
+async function uploadWorkflowBundles(client, workflows, _localMode, concurrency) {
+	if (workflows.length === 0) return [];
+	const { results } = await client.bundles.upload(workflows.map((workflow) => ({
+		workflowName: workflow.name,
+		bundleHash: workflow.bundleHash,
+		bundleSize: workflow.bundleSize,
+		bundle: workflow.bundle,
+		bundlePath: workflow.bundlePath,
+		bundleFileName: path$1.basename(workflow.bundlePath)
+	})), "deploy", { concurrency });
+	return results;
+}
+/** Uploads agent bundles to storage (cloud) or resolves local paths. Returns one result per agent. */
+async function uploadAgentBundles(client, agents, _localMode, concurrency) {
+	if (agents.length === 0) return [];
+	const { agents: agentUrls } = await client.bundles.getPresignedUrl({ agents: agents.map((agent) => ({
+		agentId: agent.agentId,
+		agentName: agent.agentName,
+		bundleHash: agent.sandboxPackageHash,
+		bundleSize: agent.sandboxPackageSize,
+		bundleFileName: path$1.basename(agent.sandboxPackagePath)
+	})) });
+	const { results } = await batchUpload(agents.map((agent) => ({
+		name: agent.agentId,
+		bundle: agent.sandboxPackage,
+		bundlePath: agent.sandboxPackagePath
+	})), agentUrls, { concurrency });
+	return results;
+}
+/** Uploads task bundles to storage (cloud) or resolves local paths. Returns one result per task. */
+async function uploadTaskBundles(client, tasks, _localMode, concurrency) {
+	if (tasks.length === 0) return [];
+	const { results } = await client.bundles.upload(tasks.map((task) => ({
+		workflowName: task.taskId,
+		bundleHash: task.bundleHash,
+		bundleSize: task.bundleSize,
+		bundle: task.bundle,
+		bundlePath: task.bundlePath,
+		bundleFileName: path$1.basename(task.bundlePath)
+	})), "deploy", { concurrency });
+	return results;
+}
+const CONCURRENT_DEPLOY_RETRY_DELAYS_MS = [
+	2e3,
+	5e3,
+	1e4
+];
+function isConcurrentVersionConflict(error) {
+	if (!error) return false;
+	return error.includes("duplicate key value violates unique constraint") && /Key \((step_id|workflow_id|authored_workflow_id), version\)=.*already exists\./.test(error);
+}
+function shouldRetryConcurrentDeployFailure(result) {
+	if (result.success) return false;
+	const failedWorkflows = result.workflows.filter((workflow) => workflow.status === "failed");
+	if (failedWorkflows.length === 0) return false;
+	if (result.agents.some((agent) => agent.status === "failed")) return false;
+	if (result.tasks?.some((task) => task.status === "failed")) return false;
+	return failedWorkflows.every((workflow) => isConcurrentVersionConflict(workflow.error));
+}
+/** Deploys workflows and agents from a build output directory. */
+async function deployFromDir(options) {
+	const { outDir, workflowsDir, client, isLocalMode: localMode = false, dryRun = false, concurrency = 5, force = false, filter, artifactFilter, artifactKinds, deploymentScope = "project", onDeployProgressEvent } = options;
+	const artifactKindSet = new Set(artifactKinds ?? [
+		"workflow",
+		"agent",
+		"task"
+	]);
+	const startTime = Date.now();
+	const projectRoot = path$1.resolve(workflowsDir);
+	const { organizationId, projectId } = await assertWorkflowProjectRoot(projectRoot);
+	const prepareStartTime = Date.now();
+	onDeployProgressEvent?.({
+		phase: "prepare",
+		status: "start",
+		workflowCount: 0
+	});
+	const warningHandler = (warning) => onDeployProgressEvent?.({
+		phase: "prepare",
+		status: "warning",
+		warning
+	});
+	const workflowFilter = artifactFilter?.workflows ?? filter;
+	const agentFilter = artifactFilter?.agents;
+	const taskFilter = artifactFilter?.tasks ?? filter;
+	const prepared = artifactKindSet.has("workflow") ? await readWorkflowsFromDisk(outDir, {
+		onWarning: warningHandler,
+		filter: workflowFilter
+	}) : [];
+	const preparedAgents = artifactKindSet.has("agent") ? await discoverAgentArtifacts(outDir, {
+		onWarning: warningHandler,
+		filter: agentFilter
+	}) : [];
+	const preparedTasks = artifactKindSet.has("task") ? await readTasksFromDisk(outDir, {
+		onWarning: warningHandler,
+		filter: taskFilter
+	}) : [];
+	const fileMetadata = await readFileMetadataArtifacts(outDir, { onWarning: warningHandler });
+	onDeployProgressEvent?.({
+		phase: "prepare",
+		status: "complete",
+		workflowCount: prepared.length,
+		agentCount: preparedAgents.length,
+		taskCount: preparedTasks.length,
+		elapsedMs: Date.now() - prepareStartTime
+	});
+	if (filter && prepared.length === 0 && preparedTasks.length === 0) {
+		onDeployProgressEvent?.({
+			phase: "filter",
+			status: "complete",
+			workflowsToUpload: 0,
+			workflowsSkipped: 0,
+			agentsToUpload: 0,
+			agentsSkipped: 0,
+			tasksToUpload: 0,
+			tasksSkipped: 0,
+			force,
+			elapsedMs: 0
+		});
+		return finalizeDeployResult({
+			workflows: [],
+			agents: [],
+			tasks: [],
+			startTime,
+			onDeployProgressEvent
+		});
+	}
+	if (dryRun) return finalizeDeployResult({
+		workflows: prepared.map((wf) => ({
+			name: wf.name,
+			status: "skipped"
+		})),
+		agents: preparedAgents.map((agent) => ({
+			name: agent.agentName,
+			status: "skipped"
+		})),
+		tasks: preparedTasks.map((task) => ({
+			name: task.name,
+			status: "skipped"
+		})),
+		startTime,
+		onDeployProgressEvent
+	});
+	let result = await executeDeploy({
+		prepared,
+		preparedAgents,
+		preparedTasks,
+		fileMetadata,
+		organizationId,
+		projectId,
+		projectRoot,
+		client,
+		localMode,
+		concurrency,
+		force,
+		deploymentScope,
+		startTime,
+		onDeployProgressEvent
+	});
+	for (const delayMs of CONCURRENT_DEPLOY_RETRY_DELAYS_MS) {
+		if (!shouldRetryConcurrentDeployFailure(result)) break;
+		await sleep(delayMs);
+		result = await executeDeploy({
+			prepared,
+			preparedAgents,
+			preparedTasks,
+			fileMetadata,
+			organizationId,
+			projectId,
+			projectRoot,
+			client,
+			localMode,
+			concurrency,
+			force,
+			deploymentScope,
+			startTime,
+			onDeployProgressEvent
+		});
+	}
+	return result;
+}
+async function executeDeploy(options) {
+	const { prepared, preparedAgents, preparedTasks, fileMetadata, organizationId, projectId, projectRoot, client, localMode, concurrency, force, deploymentScope, startTime, onDeployProgressEvent } = options;
+	const { workflowArtifacts, agentArtifacts, taskArtifacts, workflowFilter, agentFilter, taskFilter } = await hashCheckAndFilter({
+		prepared,
+		preparedAgents,
+		preparedTasks,
+		client,
+		organizationId,
+		projectId,
+		force,
+		onDeployProgressEvent
+	});
+	const workflowUploadResults = await runUploadPhase({
+		phase: "upload-workflows",
+		count: workflowFilter.workflowsToUpload.length,
+		concurrency,
+		upload: () => uploadWorkflowBundles(client, workflowFilter.workflowsToUpload, localMode, concurrency),
+		onDeployProgressEvent
+	});
+	const agentUploadResults = await runUploadPhase({
+		phase: "upload-agents",
+		count: agentFilter.agentsToUpload.length,
+		concurrency,
+		upload: () => uploadAgentBundles(client, agentFilter.agentsToUpload, localMode, concurrency),
+		onDeployProgressEvent
+	});
+	const taskUploadResults = await runUploadPhase({
+		phase: "upload-tasks",
+		count: taskFilter.tasksToUpload.length,
+		concurrency,
+		upload: () => uploadTaskBundles(client, taskFilter.tasksToUpload, localMode, concurrency),
+		onDeployProgressEvent
+	});
+	const workflowFailedUploads = toFailedUploadResults(workflowUploadResults);
+	const agentFailedUploads = toFailedUploadResults(agentUploadResults);
+	const taskFailedUploads = toFailedUploadResults(taskUploadResults);
+	const successfulWorkflowUploads = workflowUploadResults.filter((r) => r.kind === "success");
+	const successfulAgentUploads = agentUploadResults.filter((r) => r.kind === "success");
+	const successfulTaskUploads = taskUploadResults.filter((r) => r.kind === "success");
+	if (workflowFailedUploads.length > 0 || agentFailedUploads.length > 0 || taskFailedUploads.length > 0) return finalizeDeployResult({
+		workflows: [
+			...workflowFilter.skippedResults,
+			...workflowFailedUploads,
+			...successfulWorkflowUploads.map((u) => ({
+				name: u.name,
+				status: "skipped"
+			}))
+		],
+		agents: [
+			...agentFilter.skippedResults,
+			...agentFailedUploads,
+			...successfulAgentUploads.map((u) => ({
+				name: u.name,
+				status: "skipped"
+			}))
+		],
+		tasks: [
+			...taskFilter.skippedResults,
+			...taskFailedUploads,
+			...successfulTaskUploads.map((u) => ({
+				name: u.name,
+				status: "skipped"
+			}))
+		],
+		startTime,
+		onDeployProgressEvent
+	});
+	const registration = await registerDeployment({
+		prepared,
+		preparedAgents,
+		preparedTasks,
+		successfulWorkflowUploads,
+		successfulAgentUploads,
+		successfulTaskUploads,
+		workflowArtifacts,
+		agentArtifacts,
+		taskArtifacts,
+		projectId,
+		organizationId,
+		projectRoot,
+		client,
+		force,
+		deploymentScope,
+		onDeployProgressEvent
+	});
+	if (!(registration.workflows.some((wf) => wf.status === "failed") || registration.agents.some((a) => a.status === "failed") || registration.tasks.some((t) => t.status === "failed"))) await syncMetadata({
+		client,
+		organizationId,
+		projectId,
+		fileMetadata,
+		onDeployProgressEvent
+	});
+	return finalizeDeployResult({
+		workflows: registration.workflows,
+		agents: registration.agents,
+		tasks: registration.tasks,
+		startTime,
+		onDeployProgressEvent
+	});
+}
+async function sleep(ms) {
+	await new Promise((resolve) => setTimeout(resolve, ms));
+}
+//#endregion
+export { readManifestsFromOutDir as a, readAgentManifestsFromOutDir as i, deployFromDir as n, readWorkflowsFromDisk as o, dist_exports as r, uploadTestBundle as s, collectCredentialFingerprintMapFromProjectDist as t };