@tailor-platform/sdk 1.67.0 → 1.68.0

package/dist/{runtime-BU6KtCvk.mjs → runtime-DxaBq6U8.mjs}

@@ -39,6 +39,7 @@ import * as inflection from "inflection";
 import { pathToString } from "@bufbuild/protobuf/reflect";
 import { createValidator } from "@bufbuild/protovalidate";
 import { setTimeout as setTimeout$1 } from "timers/promises";
+import { setTimeout as setTimeout$2 } from "node:timers/promises";
 import { spawn } from "node:child_process";
 import { watch } from "chokidar";
 import * as madgeModule from "madge";
@@ -4891,7 +4892,7 @@ async function readConfigId(configPath) {
 async function assertConfigIdInCI(configPath) {
 	const result = await readConfigId(configPath);
 	if (result === null) return;
-	if (!result.id) throw new Error("tailor.config.ts is missing an 'id'. CI does not auto-generate one (each run would be treated as a separate app and break resource ownership). Run 'tailor-sdk setup github' or 'tailor-sdk apply' locally and commit the injected id.");
+	if (!result.id) throw new Error("tailor.config.ts is missing an 'id'. CI does not auto-generate one (each run would be treated as a separate app and break resource ownership). Run 'tailor-sdk setup' or 'tailor-sdk apply' locally and commit the injected id.");
 	if (!uuidRegex.test(result.id)) throw new Error(`'id' in ${configPath} must be a UUID. To use this config for a separate app, delete it.`);
 }
 /**
@@ -8700,7 +8701,7 @@ const DEFAULT_POLL_INTERVAL = 1e3;
 * @returns {Promise<ExecutionWaitResult>} Execution result
 * @throws {Error} If execution is not found
 */
-async function waitForExecution$1(client, workspaceId, executionId, pollInterval = DEFAULT_POLL_INTERVAL) {
+async function waitForExecution(client, workspaceId, executionId, pollInterval = DEFAULT_POLL_INTERVAL) {
 	while (true) {
 		const { execution } = await client.getFunctionExecution({
 			workspaceId,
@@ -8735,7 +8736,7 @@ async function executeScript(options) {
 		invoker
 	});
 	const executionId = response.executionId;
-	const result = await waitForExecution$1(client, workspaceId, executionId, pollInterval);
+	const result = await waitForExecution(client, workspaceId, executionId, pollInterval);
 	if (result.status === FunctionExecution_Status.SUCCESS) return {
 		success: true,
 		logs: result.logs,
@@ -11178,7 +11179,42 @@ function colorizeExecutorJobStatus(status) {
 * @returns True if status is terminal
 */
 function isExecutorJobTerminalStatus(status) {
-	return status === ExecutorJobStatus.SUCCESS || status === ExecutorJobStatus.FAILED || status === ExecutorJobStatus.CANCELED;
+	return isExecutorJobSuccessStatus(status) || isExecutorJobFailureStatus(status);
+}
+/**
+* Check if executor job status is successful.
+* @param status - Executor job status enum value
+* @returns True if status is success
+*/
+function isExecutorJobSuccessStatus(status) {
+	return status === ExecutorJobStatus.SUCCESS;
+}
+/**
+* Check if executor job status is a terminal failure.
+* @param status - Executor job status enum value
+* @returns True if status is failure
+*/
+function isExecutorJobFailureStatus(status) {
+	return status === ExecutorJobStatus.FAILED || status === ExecutorJobStatus.CANCELED;
+}
+/**
+* Check if executor job status can still progress.
+* @param status - Executor job status enum value
+* @returns True if status is transient
+*/
+function isExecutorJobTransientStatus(status) {
+	return status === ExecutorJobStatus.UNSPECIFIED || status === ExecutorJobStatus.PENDING || status === ExecutorJobStatus.RUNNING;
+}
+/**
+* Classify executor job status for waiter decisions.
+* @param status - Executor job status enum value
+* @returns Classified executor job status
+*/
+function classifyExecutorJobStatus(status) {
+	if (isExecutorJobSuccessStatus(status)) return "success";
+	if (isExecutorJobTerminalStatus(status)) return "failure";
+	if (isExecutorJobTransientStatus(status)) return "transient";
+	return "transient";
 }
 /**
 * Parse executor job status string to enum.
@@ -11570,36 +11606,158 @@ function functionExecutionStatusToString(status) {
 	}
 }
 
+//#endregion
+//#region src/cli/shared/wait-error.ts
+/**
+* Format a caught error into a string for diagnostics.
+* @param error - Error to format
+* @returns Error message string
+*/
+function formatWaitError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Check whether a polling error is retryable (transient platform errors).
+* @param error - Error to check
+* @returns True if the error should be retried
+*/
+function isRetryableWaitError(error) {
+	if (!(error instanceof ConnectError)) return false;
+	return error.code === Code.Aborted || error.code === Code.ResourceExhausted || error.code === Code.Unavailable;
+}
+
 //#endregion
 //#region src/cli/commands/workflow/args.ts
+const workflowWaitUntilArg = z.enum([
+	"success",
+	"suspended",
+	"terminal"
+]);
 const nameArgs = { name: arg(z.string(), {
 	positional: true,
 	description: "Workflow name"
 }) };
-const waitArgs = {
-	wait: arg(z.boolean().default(false), {
-		alias: "W",
-		description: "Wait for execution to complete"
-	}),
+const workflowWaitControlArgs = {
 	interval: arg(durationArg.default("3s"), {
 		alias: "i",
-		description: "Polling interval when using --wait (e.g., '3s', '500ms', '1m')"
+		description: "Polling interval when waiting (e.g., '3s', '500ms', '1m')"
+	}),
+	timeout: arg(durationArg.default("10m"), {
+		alias: "t",
+		description: "Maximum time to wait (e.g., '30s', '10m')"
+	}),
+	until: arg(workflowWaitUntilArg.default("terminal"), {
+		alias: "u",
+		description: "Wait target (success, suspended, terminal)"
 	}),
 	logs: arg(z.boolean().default(false), {
 		alias: "l",
-		description: "Display job execution logs after completion (requires --wait)"
+		description: "Display job execution logs after completion"
 	})
 };
+const waitArgs = {
+	wait: arg(z.boolean().default(false), {
+		alias: "W",
+		description: "Wait for execution to complete"
+	}),
+	...workflowWaitControlArgs
+};
 
 //#endregion
 //#region src/cli/commands/workflow/status.ts
 /**
+* Check if workflow execution status is successful.
+* @param status - Workflow execution status enum value
+* @returns True if status is success
+*/
+function isWorkflowExecutionSuccessStatus(status) {
+	return status === WorkflowExecution_Status.SUCCESS;
+}
+/**
+* Check if workflow job execution status is suspended or waiting.
+* @param status - Workflow job execution status enum value
+* @returns True if status represents a wait point
+*/
+function isWorkflowJobExecutionSuspendedStatus(status) {
+	return status === WorkflowJobExecution_Status.SUSPEND || status === WorkflowJobExecution_Status.WAITING;
+}
+/**
+* Check if workflow execution status is suspended or waiting.
+* @param status - Workflow execution status enum value
+* @returns True if status represents a suspended execution
+*/
+function isWorkflowExecutionSuspendedStatus(status) {
+	return status === WorkflowExecution_Status.PENDING_RESUME || status === WorkflowExecution_Status.WAITING;
+}
+/**
+* Check if workflow execution status is a terminal failure.
+* @param status - Workflow execution status enum value
+* @returns True if status represents failure
+*/
+function isWorkflowExecutionFailureStatus(status) {
+	return status === WorkflowExecution_Status.FAILED;
+}
+/**
+* Check if workflow execution status can still progress without user action.
+* @param status - Workflow execution status enum value
+* @returns True if status is transient
+*/
+function isWorkflowExecutionTransientStatus(status) {
+	return status === WorkflowExecution_Status.UNSPECIFIED || status === WorkflowExecution_Status.PENDING || status === WorkflowExecution_Status.RUNNING || status === WorkflowExecution_Status.PENDING_RETRY;
+}
+/**
 * Check if workflow execution status is terminal.
 * @param status - Workflow execution status enum value
 * @returns True if status is terminal
 */
 function isWorkflowExecutionTerminalStatus(status) {
-	return status === WorkflowExecution_Status.SUCCESS || status === WorkflowExecution_Status.FAILED || status === WorkflowExecution_Status.PENDING_RESUME;
+	return isWorkflowExecutionSuccessStatus(status) || isWorkflowExecutionFailureStatus(status) || isWorkflowExecutionSuspendedStatus(status);
+}
+/**
+* Classify workflow execution status for waiter decisions.
+* @param execution - Workflow execution to classify
+* @returns Classified workflow execution status
+*/
+function classifyWorkflowExecutionStatus(execution) {
+	if (isWorkflowExecutionTerminalStatus(execution.status)) {
+		if (isWorkflowExecutionSuccessStatus(execution.status)) return {
+			statusClass: "success",
+			status: execution.status
+		};
+		if (isWorkflowExecutionFailureStatus(execution.status)) return {
+			statusClass: "failure",
+			status: execution.status
+		};
+		return {
+			statusClass: "suspended",
+			status: execution.status
+		};
+	}
+	if (execution.jobExecutions.some((job) => isWorkflowJobExecutionSuspendedStatus(job.status))) return {
+		statusClass: "suspended",
+		status: execution.status
+	};
+	if (isWorkflowExecutionTransientStatus(execution.status)) return {
+		statusClass: "transient",
+		status: execution.status
+	};
+	return {
+		statusClass: "transient",
+		status: execution.status
+	};
+}
+/**
+* Check if a classified workflow execution has reached the requested waiter target.
+* @param classification - Workflow execution status classification
+* @param until - Requested wait target
+* @returns True if the wait target is reached
+*/
+function hasReachedWorkflowWaitTarget(classification, until) {
+	switch (until) {
+		case "success": return classification.statusClass === "success";
+		case "suspended": return classification.statusClass === "suspended";
+		case "terminal": return classification.statusClass === "success" || classification.statusClass === "failure" || classification.statusClass === "suspended";
+	}
 }
 
 //#endregion
@@ -11616,6 +11774,8 @@ function workflowExecutionStatusToString(status) {
 		case WorkflowExecution_Status.RUNNING: return "RUNNING";
 		case WorkflowExecution_Status.SUCCESS: return "SUCCESS";
 		case WorkflowExecution_Status.FAILED: return "FAILED";
+		case WorkflowExecution_Status.PENDING_RETRY: return "PENDING_RETRY";
+		case WorkflowExecution_Status.WAITING: return "WAITING";
 		default: return "UNSPECIFIED";
 	}
 }
@@ -11630,6 +11790,7 @@ function workflowJobExecutionStatusToString(status) {
 		case WorkflowJobExecution_Status.SUSPEND: return "SUSPEND";
 		case WorkflowJobExecution_Status.SUCCESS: return "SUCCESS";
 		case WorkflowJobExecution_Status.FAILED: return "FAILED";
+		case WorkflowJobExecution_Status.WAITING: return "WAITING";
 		default: return "UNSPECIFIED";
 	}
 }
@@ -11695,24 +11856,200 @@ function toWorkflowExecutionInfo(execution) {
 }
 
 //#endregion
-//#region src/cli/commands/workflow/executions.ts
-function sleep$1(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function formatTime$2(date) {
+//#region src/cli/commands/workflow/waiter.ts
+const DEFAULT_WORKFLOW_WAIT_INTERVAL_MS = 3e3;
+function formatTime$1(date) {
 	return date.toLocaleTimeString("en-US", { hour12: false });
 }
-function colorizeStatus$1(status) {
+function colorizeStatus(status) {
 	const statusText = WorkflowExecution_Status[status];
 	switch (status) {
-		case WorkflowExecution_Status.PENDING: return styles.dim(statusText);
-		case WorkflowExecution_Status.PENDING_RESUME: return styles.warning(statusText);
+		case WorkflowExecution_Status.PENDING:
+		case WorkflowExecution_Status.UNSPECIFIED: return styles.dim(statusText);
+		case WorkflowExecution_Status.PENDING_RESUME:
+		case WorkflowExecution_Status.PENDING_RETRY:
+		case WorkflowExecution_Status.WAITING: return styles.warning(statusText);
 		case WorkflowExecution_Status.RUNNING: return styles.info(statusText);
 		case WorkflowExecution_Status.SUCCESS: return styles.success(statusText);
 		case WorkflowExecution_Status.FAILED: return styles.error(statusText);
 		default: return statusText;
 	}
 }
+function getActiveJobs(execution) {
+	return execution.jobExecutions.filter((job) => job.status === WorkflowJobExecution_Status.RUNNING || job.status === WorkflowJobExecution_Status.SUSPEND || job.status === WorkflowJobExecution_Status.WAITING).map((job) => job.stackedJobName).join(", ");
+}
+function createWorkflowWaitResult(options) {
+	const elapsedMs = Date.now() - options.startedAt;
+	if (options.execution) {
+		const classification = classifyWorkflowExecutionStatus(options.execution);
+		return {
+			...toWorkflowExecutionInfo(options.execution),
+			statusClass: classification.statusClass,
+			elapsedMs,
+			attempts: options.attempts,
+			timedOut: options.timedOut,
+			lastError: options.lastError
+		};
+	}
+	return {
+		id: options.executionId,
+		workflowName: "",
+		status: "UNKNOWN",
+		statusClass: "unknown",
+		jobExecutions: 0,
+		startedAt: null,
+		finishedAt: null,
+		elapsedMs,
+		attempts: options.attempts,
+		timedOut: options.timedOut,
+		lastError: options.lastError
+	};
+}
+/**
+* Wait for a workflow execution to reach the requested state.
+* @param options - Workflow waiter options
+* @returns Final or timed-out workflow wait result
+*/
+async function waitForWorkflowExecution(options) {
+	const interval = options.interval ?? 3e3;
+	const until = options.until ?? "terminal";
+	const startedAt = Date.now();
+	const sp = options.showProgress ? spinner({ indent: 2 }).start("Waiting for workflow to complete...") : null;
+	let attempts = 0;
+	let lastExecution;
+	let lastError = null;
+	let lastStatus;
+	let lastActiveJobs;
+	try {
+		while (true) {
+			const elapsedMs = Date.now() - startedAt;
+			const remainingMs = options.timeout === void 0 ? void 0 : options.timeout - elapsedMs;
+			if (remainingMs !== void 0 && remainingMs <= 0) {
+				sp?.fail("Workflow wait timed out.");
+				return createWorkflowWaitResult({
+					executionId: options.executionId,
+					execution: lastExecution,
+					startedAt,
+					attempts,
+					timedOut: true,
+					lastError
+				});
+			}
+			try {
+				attempts += 1;
+				const { execution } = await options.client.getWorkflowExecution({
+					workspaceId: options.workspaceId,
+					executionId: options.executionId
+				});
+				if (!execution) {
+					sp?.fail(`Execution '${options.executionId}' not found.`);
+					throw new Error(`Execution '${options.executionId}' not found.`);
+				}
+				lastExecution = execution;
+				lastError = null;
+				const classification = classifyWorkflowExecutionStatus(execution);
+				const coloredStatus = colorizeStatus(execution.status);
+				if (execution.status !== lastStatus) {
+					if (options.showProgress) {
+						sp?.stop();
+						logger.info(`Status: ${coloredStatus}`, {
+							mode: "stream",
+							indent: 2
+						});
+						sp?.start("Waiting for workflow to complete...");
+					}
+					lastStatus = execution.status;
+				}
+				if (options.trackJobs) {
+					const activeJobs = getActiveJobs(execution);
+					if (activeJobs && activeJobs !== lastActiveJobs) {
+						if (options.showProgress) {
+							sp?.stop();
+							logger.info(`Job | ${activeJobs}: ${coloredStatus}`, {
+								mode: "stream",
+								indent: 2
+							});
+							sp?.start("Waiting for workflow to complete...");
+						}
+						lastActiveJobs = activeJobs;
+					}
+				}
+				if (sp) sp.text = `Waiting for workflow to complete... (${formatTime$1(/* @__PURE__ */ new Date())})`;
+				if (hasReachedWorkflowWaitTarget(classification, until) || classification.statusClass === "failure" || until === "suspended" && classification.statusClass === "success") {
+					if (execution.status === WorkflowExecution_Status.SUCCESS) sp?.succeed(`Completed: ${coloredStatus}`);
+					else if (isWorkflowExecutionFailureStatus(execution.status)) sp?.fail(`Completed: ${coloredStatus}`);
+					else if (isWorkflowExecutionSuspendedStatus(execution.status)) sp?.warn(`Completed: ${coloredStatus}`);
+					else sp?.succeed(`Completed: ${coloredStatus}`);
+					return createWorkflowWaitResult({
+						executionId: options.executionId,
+						execution,
+						startedAt,
+						attempts,
+						timedOut: false,
+						lastError
+					});
+				}
+			} catch (error) {
+				if (!isRetryableWaitError(error)) throw error;
+				lastError = formatWaitError(error);
+				if (options.showProgress) {
+					if (sp) sp.text = `Retrying workflow status poll... (${formatTime$1(/* @__PURE__ */ new Date())})`;
+				}
+			}
+			const nextElapsedMs = Date.now() - startedAt;
+			const nextRemainingMs = options.timeout === void 0 ? void 0 : options.timeout - nextElapsedMs;
+			if (nextRemainingMs !== void 0 && nextRemainingMs <= 0) {
+				sp?.fail("Workflow wait timed out.");
+				return createWorkflowWaitResult({
+					executionId: options.executionId,
+					execution: lastExecution,
+					startedAt,
+					attempts,
+					timedOut: true,
+					lastError
+				});
+			}
+			await setTimeout$2(nextRemainingMs === void 0 ? interval : Math.min(interval, nextRemainingMs));
+		}
+	} finally {
+		sp?.stop();
+	}
+}
+/**
+* Wait for an existing workflow execution by ID.
+* @param options - Workflow execution wait options
+* @returns Workflow wait result
+*/
+async function waitForWorkflowExecutionById(options) {
+	return await waitForWorkflowExecution({
+		client: await initOperatorClient(await loadAccessToken({ profile: options.profile })),
+		workspaceId: await loadWorkspaceId({
+			workspaceId: options.workspaceId,
+			profile: options.profile
+		}),
+		executionId: options.executionId,
+		interval: options.interval,
+		timeout: options.timeout,
+		until: options.until,
+		showProgress: options.showProgress,
+		trackJobs: options.trackJobs
+	});
+}
+/**
+* Build a user-facing failure message for a workflow wait result.
+* @param result - Workflow wait result
+* @param until - Requested wait target
+* @returns Failure message, or undefined when the wait succeeded
+*/
+function getWorkflowWaitFailureMessage(result, until) {
+	if (result.timedOut) return `Timed out waiting for workflow execution '${result.id}' to reach ${until}. Last status: ${result.status}.`;
+	if (result.status === "FAILED") return `Workflow execution '${result.id}' failed.`;
+	if (until === "success" && result.statusClass !== "success") return `Workflow execution '${result.id}' reached ${result.status} before success.`;
+	if (until === "suspended" && result.statusClass !== "suspended") return `Workflow execution '${result.id}' reached ${result.status} before suspension.`;
+}
+
+//#endregion
+//#region src/cli/commands/workflow/executions.ts
 function parseStatus(status) {
 	switch (status.toUpperCase()) {
 		case "PENDING": return WorkflowExecution_Status.PENDING;
@@ -11720,7 +12057,10 @@ function parseStatus(status) {
 		case "RUNNING": return WorkflowExecution_Status.RUNNING;
 		case "SUCCESS": return WorkflowExecution_Status.SUCCESS;
 		case "FAILED": return WorkflowExecution_Status.FAILED;
-		default: throw new Error(`Invalid status: ${status}. Valid values: PENDING, PENDING_RESUME, RUNNING, SUCCESS, FAILED`);
+		case "PENDING_RETRY": return WorkflowExecution_Status.PENDING_RETRY;
+		case "WAITING": return WorkflowExecution_Status.WAITING;
+		case "UNSPECIFIED": return WorkflowExecution_Status.UNSPECIFIED;
+		default: throw new Error(`Invalid status: ${status}. Valid values: UNSPECIFIED, PENDING, PENDING_RESUME, RUNNING, SUCCESS, FAILED, PENDING_RETRY, WAITING`);
 	}
 }
 async function listWorkflowExecutions(options) {
@@ -11809,37 +12149,28 @@ async function getWorkflowExecution(options) {
 	}
 	async function waitForCompletion() {
 		const interval = options.interval ?? 3e3;
-		while (true) {
-			const { execution } = await client.getWorkflowExecution({
-				workspaceId,
-				executionId: options.executionId
-			});
-			if (!execution) throw new Error(`Execution '${options.executionId}' not found.`);
-			if (isWorkflowExecutionTerminalStatus(execution.status)) return await fetchExecutionWithLogs(options.executionId, options.logs ?? false);
-			await sleep$1(interval);
-		}
+		const waitResult = await waitForWorkflowExecution({
+			client,
+			workspaceId,
+			executionId: options.executionId,
+			interval,
+			timeout: options.timeout,
+			until: options.until ?? "terminal"
+		});
+		return {
+			...await fetchExecutionWithLogs(options.executionId, options.logs ?? false),
+			statusClass: waitResult.statusClass,
+			elapsedMs: waitResult.elapsedMs,
+			attempts: waitResult.attempts,
+			timedOut: waitResult.timedOut,
+			lastError: waitResult.lastError
+		};
 	}
 	return {
 		execution: await fetchExecutionWithLogs(options.executionId, options.logs ?? false),
 		wait: waitForCompletion
 	};
 }
-async function waitWithSpinner(waitFn, interval, json) {
-	const sp = !json ? spinner().start("Waiting for workflow to complete...") : null;
-	const updateInterval = setInterval(() => {
-		if (sp) sp.text = `Waiting for workflow to complete... (${formatTime$2(/* @__PURE__ */ new Date())})`;
-	}, interval);
-	try {
-		const result = await waitFn();
-		const coloredStatus = colorizeStatus$1(WorkflowExecution_Status[result.status]);
-		if (result.status === "SUCCESS") sp?.succeed(`Completed: ${coloredStatus}`);
-		else sp?.fail(`Completed: ${coloredStatus}`);
-		return result;
-	} finally {
-		clearInterval(updateInterval);
-		sp?.stop();
-	}
-}
 /**
 * Print a workflow execution and its logs in a human-readable format.
 * @param execution - Workflow execution detail info
@@ -11901,19 +12232,55 @@ const executionsCommand = defineAppCommand({
 		logs: arg(z.boolean().default(false), { description: "Display job execution logs (detail mode only)" })
 	}).strict(),
 	run: async (args) => {
+		const jsonOutput = logger.jsonMode || args.json;
 		if (args.executionId) {
 			const interval = parseDuration(args.interval);
-			const { execution, wait } = await getWorkflowExecution({
+			if (!jsonOutput) logger.info(`Execution ID: ${args.executionId}`, { mode: "stream" });
+			if (args.wait) {
+				const result = await waitForWorkflowExecutionById({
+					executionId: args.executionId,
+					workspaceId: args["workspace-id"],
+					profile: args.profile,
+					interval,
+					timeout: parseDuration(args.timeout),
+					until: args.until,
+					showProgress: !jsonOutput,
+					trackJobs: true
+				});
+				if (args.logs && !jsonOutput) {
+					const { execution } = await getWorkflowExecution({
+						executionId: args.executionId,
+						workspaceId: args["workspace-id"],
+						profile: args.profile,
+						logs: true
+					});
+					printExecutionWithLogs(execution);
+				} else if (args.logs) {
+					const { execution } = await getWorkflowExecution({
+						executionId: args.executionId,
+						workspaceId: args["workspace-id"],
+						profile: args.profile,
+						logs: true
+					});
+					const output = {
+						...result,
+						jobDetails: execution.jobDetails
+					};
+					logger.out(output);
+				} else logger.out(result);
+				const failureMessage = getWorkflowWaitFailureMessage(result, args.until);
+				if (failureMessage) throw new Error(failureMessage);
+				return;
+			}
+			const { execution } = await getWorkflowExecution({
 				executionId: args.executionId,
 				workspaceId: args["workspace-id"],
 				profile: args.profile,
 				interval,
 				logs: args.logs
 			});
-			if (!args.json) logger.info(`Execution ID: ${execution.id}`, { mode: "stream" });
-			const result = args.wait ? await waitWithSpinner(wait, interval, args.json) : execution;
-			if (args.logs && !args.json) printExecutionWithLogs(result);
-			else logger.out(result);
+			if (args.logs && !jsonOutput) printExecutionWithLogs(execution);
+			else logger.out(execution);
 		} else {
 			const executions = await listWorkflowExecutions({
 				workspaceId: args["workspace-id"],
@@ -11978,90 +12345,6 @@ const getCommand$5 = defineAppCommand({
 
 //#endregion
 //#region src/cli/commands/workflow/start.ts
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function formatTime$1(date) {
-	return date.toLocaleTimeString("en-US", { hour12: false });
-}
-function colorizeStatus(status) {
-	const statusText = WorkflowExecution_Status[status];
-	switch (status) {
-		case WorkflowExecution_Status.PENDING: return styles.dim(statusText);
-		case WorkflowExecution_Status.PENDING_RESUME: return styles.warning(statusText);
-		case WorkflowExecution_Status.RUNNING: return styles.info(statusText);
-		case WorkflowExecution_Status.SUCCESS: return styles.success(statusText);
-		case WorkflowExecution_Status.FAILED: return styles.error(statusText);
-		default: return statusText;
-	}
-}
-/**
-* Wait for a workflow execution to reach a terminal state, optionally showing progress.
-* @param options - Wait options
-* @returns Final workflow execution info
-*/
-async function waitForExecution(options) {
-	const { client, workspaceId, executionId, interval, showProgress, trackJobs } = options;
-	let lastStatus;
-	let lastRunningJobs;
-	const sp = showProgress ? spinner({ indent: 2 }).start("Waiting for workflow to complete...") : null;
-	try {
-		while (true) {
-			const { execution } = await client.getWorkflowExecution({
-				workspaceId,
-				executionId
-			});
-			if (!execution) {
-				sp?.fail(`Execution '${executionId}' not found.`);
-				throw new Error(`Execution '${executionId}' not found.`);
-			}
-			const now = formatTime$1(/* @__PURE__ */ new Date());
-			const coloredStatus = colorizeStatus(execution.status);
-			if (execution.status !== lastStatus) {
-				if (showProgress) {
-					sp?.stop();
-					logger.info(`Status: ${coloredStatus}`, {
-						mode: "stream",
-						indent: 2
-					});
-					sp?.start(`Waiting for workflow to complete...`);
-				}
-				lastStatus = execution.status;
-			}
-			if (trackJobs && execution.status === WorkflowExecution_Status.RUNNING) {
-				const runningJobs = getRunningJobs(execution);
-				if (runningJobs && runningJobs !== lastRunningJobs) {
-					if (showProgress) {
-						sp?.stop();
-						logger.info(`Job | ${runningJobs}: ${coloredStatus}`, {
-							mode: "stream",
-							indent: 2
-						});
-						sp?.start(`Waiting for workflow to complete...`);
-					}
-					lastRunningJobs = runningJobs;
-				}
-			}
-			if (sp) sp.text = `Waiting for workflow to complete... (${now})`;
-			if (isTerminalStatus(execution.status)) {
-				if (execution.status === WorkflowExecution_Status.SUCCESS) sp?.succeed(`Completed: ${coloredStatus}`);
-				else if (execution.status === WorkflowExecution_Status.FAILED) sp?.fail(`Completed: ${coloredStatus}`);
-				else sp?.warn(`Completed: ${coloredStatus}`);
-				return toWorkflowExecutionInfo(execution);
-			}
-			await sleep(interval);
-		}
-	} catch (error) {
-		sp?.stop();
-		throw error;
-	}
-}
-function getRunningJobs(execution) {
-	return execution.jobExecutions.filter((job) => job.status === WorkflowJobExecution_Status.RUNNING).map((job) => job.stackedJobName).join(", ");
-}
-function isTerminalStatus(status) {
-	return status === WorkflowExecution_Status.SUCCESS || status === WorkflowExecution_Status.FAILED || status === WorkflowExecution_Status.PENDING_RESUME;
-}
 async function startWorkflowCore(options) {
 	const { client, workspaceId, workflowName } = options;
 	try {
@@ -12076,11 +12359,13 @@ async function startWorkflowCore(options) {
 		});
 		return {
 			executionId,
-			wait: (waitOptions) => waitForExecution({
+			wait: (waitOptions) => waitForWorkflowExecution({
 				client,
 				workspaceId,
 				executionId,
 				interval: options.interval ?? 3e3,
+				timeout: waitOptions?.timeout,
+				until: waitOptions?.until,
 				showProgress: waitOptions?.showProgress,
 				trackJobs: true
 			})
@@ -12164,7 +12449,11 @@ const startCommand = defineAppCommand({
 		const jsonOutput = logger.jsonMode;
 		logger.info(`Execution ID: ${executionId}`, { mode: "stream" });
 		if (args.wait) {
-			const result = await wait({ showProgress: !jsonOutput });
+			const result = await wait({
+				showProgress: !jsonOutput,
+				timeout: parseDuration(args.timeout),
+				until: args.until
+			});
 			if (args.logs && !jsonOutput) {
 				const { execution } = await getWorkflowExecution({
 					executionId,
@@ -12173,7 +12462,20 @@ const startCommand = defineAppCommand({
 					logs: true
 				});
 				printExecutionWithLogs(execution);
+			} else if (args.logs) {
+				const { execution } = await getWorkflowExecution({
+					executionId,
+					workspaceId: args["workspace-id"],
+					profile: args.profile,
+					logs: true
+				});
+				logger.out({
+					...result,
+					jobDetails: execution.jobDetails
+				});
 			} else logger.out(result);
+			const failureMessage = getWorkflowWaitFailureMessage(result, args.until);
+			if (failureMessage) throw new Error(failureMessage);
 		} else logger.out({ executionId });
 	}
 });
@@ -12183,6 +12485,16 @@ const startCommand = defineAppCommand({
 function formatTime(date) {
 	return date.toLocaleTimeString("en-US", { hour12: false });
 }
+function createUnknownExecutorJob(executorName, jobId) {
+	return {
+		id: jobId,
+		executorName,
+		status: "UNKNOWN",
+		scheduledAt: "N/A",
+		createdAt: "N/A",
+		updatedAt: "N/A"
+	};
+}
 async function listExecutorJobs(options) {
 	const executorName = "executorName" in options ? options.executorName : options.executor.name;
 	const client = await initOperatorClient(await loadAccessToken({ profile: options.profile }));
@@ -12266,7 +12578,27 @@ async function watchExecutorJob(options) {
 		profile: options.profile
 	});
 	const interval = options.interval ?? 3e3;
-	const sp = spinner().start("Waiting for executor job to complete...");
+	const timeout = options.timeout;
+	const showProgress = options.showProgress ?? !logger.jsonMode;
+	const startedAt = Date.now();
+	const sp = showProgress ? spinner().start("Waiting for executor job to complete...") : null;
+	let attempts = 0;
+	let lastError = null;
+	const remainingTimeout = () => {
+		if (timeout === void 0) return;
+		return timeout - (Date.now() - startedAt);
+	};
+	const withWaitMetadata = (result, timedOut) => ({
+		...result,
+		elapsedMs: Date.now() - startedAt,
+		attempts,
+		timedOut,
+		lastError
+	});
+	const timeoutResult = (targetType, job) => withWaitMetadata({
+		job: job ? toExecutorJobInfo(job) : createUnknownExecutorJob(executorName, options.jobId),
+		targetType
+	}, true);
 	try {
 		const { executor } = await client.getExecutorExecutor({
 			workspaceId,
@@ -12277,29 +12609,47 @@ async function watchExecutorJob(options) {
 		const targetTypeStr = executorTargetTypeToString(targetType);
 		let job;
 		while (true) {
-			job = (await client.getExecutorJob({
-				workspaceId,
-				executorName,
-				jobId: options.jobId
-			})).job;
-			if (!job) throw new Error(`Job '${options.jobId}' not found.`);
-			if (isExecutorJobTerminalStatus(job.status)) break;
-			sp.text = `Waiting for executor job... (${formatTime(/* @__PURE__ */ new Date())})`;
-			await setTimeout$1(interval);
+			const remainingMs = remainingTimeout();
+			if (remainingMs !== void 0 && remainingMs <= 0) {
+				sp?.fail("Executor job wait timed out.");
+				return timeoutResult(targetTypeStr, job);
+			}
+			try {
+				attempts += 1;
+				job = (await client.getExecutorJob({
+					workspaceId,
+					executorName,
+					jobId: options.jobId
+				})).job;
+				if (!job) throw new Error(`Job '${options.jobId}' not found.`);
+				lastError = null;
+				if (classifyExecutorJobStatus(job.status) !== "transient") break;
+			} catch (error) {
+				if (!isRetryableWaitError(error)) throw error;
+				lastError = formatWaitError(error);
+				if (sp) sp.text = `Retrying executor job poll... (${formatTime(/* @__PURE__ */ new Date())})`;
+			}
+			const nextRemainingMs = remainingTimeout();
+			if (nextRemainingMs !== void 0 && nextRemainingMs <= 0) {
+				sp?.fail("Executor job wait timed out.");
+				return timeoutResult(targetTypeStr, job);
+			}
+			if (sp) sp.text = `Waiting for executor job... (${formatTime(/* @__PURE__ */ new Date())})`;
+			await setTimeout$1(nextRemainingMs === void 0 ? interval : Math.min(interval, nextRemainingMs));
 		}
 		const jobInfo = toExecutorJobInfo(job);
 		const coloredStatus = colorizeExecutorJobStatus(jobInfo.status);
-		if (job.status === ExecutorJobStatus.SUCCESS) sp.succeed(`Executor job completed: ${coloredStatus}`);
-		else sp.fail(`Executor job completed: ${coloredStatus}`);
+		if (job.status === ExecutorJobStatus.SUCCESS) sp?.succeed(`Executor job completed: ${coloredStatus}`);
+		else sp?.fail(`Executor job completed: ${coloredStatus}`);
 		const attemptInfos = (await fetchAll(async (pageToken, maxPageSize) => {
-			const { attempts, nextPageToken } = await client.listExecutorJobAttempts({
+			const { attempts: jobAttempts, nextPageToken } = await client.listExecutorJobAttempts({
 				workspaceId,
 				jobId: options.jobId,
 				pageToken,
 				pageSize: maxPageSize,
 				pageDirection: PageDirection.DESC
 			});
-			return [attempts, nextPageToken];
+			return [jobAttempts, nextPageToken];
 		})).map(toExecutorJobAttemptInfo);
 		const jobDetail = {
 			...jobInfo,
@@ -12308,18 +12658,27 @@ async function watchExecutorJob(options) {
 		const operationReference = attemptInfos[0]?.operationReference;
 		if (operationReference) switch (targetType) {
 			case ExecutorTargetType.WORKFLOW:
-				sp.stop();
+				sp?.stop();
 				try {
-					const executionResult = await waitForExecution({
+					const workflowTimeout = remainingTimeout();
+					if (workflowTimeout !== void 0 && workflowTimeout <= 0) return withWaitMetadata({
+						job: jobDetail,
+						targetType: targetTypeStr,
+						workflowExecutionId: operationReference
+					}, true);
+					const executionResult = await waitForWorkflowExecution({
 						client,
 						workspaceId,
 						executionId: operationReference,
 						interval,
-						showProgress: true,
+						timeout: workflowTimeout,
+						showProgress,
 						trackJobs: true
 					});
+					attempts += executionResult.attempts;
+					lastError = executionResult.lastError;
 					let workflowJobLogs;
-					if (options.logs) {
+					if (options.logs) try {
 						const { execution: execWithLogs } = await getWorkflowExecution({
 							executionId: operationReference,
 							workspaceId: options.workspaceId,
@@ -12331,67 +12690,109 @@ async function watchExecutorJob(options) {
 							logs: job.logs,
 							result: job.result
 						}));
+					} catch (error) {
+						logger.warn(`Could not fetch workflow execution logs: ${error instanceof Error ? error.message : error}`);
 					}
-					return {
+					return withWaitMetadata({
 						job: jobDetail,
 						targetType: targetTypeStr,
 						workflowExecutionId: operationReference,
 						workflowStatus: executionResult.status,
 						workflowJobLogs
-					};
+					}, executionResult.timedOut);
 				} catch (error) {
 					logger.warn(`Could not track workflow execution: ${error instanceof Error ? error.message : error}`);
-					return {
+					return withWaitMetadata({
 						job: jobDetail,
 						targetType: targetTypeStr,
 						workflowExecutionId: operationReference
-					};
+					}, false);
 				}
 			case ExecutorTargetType.FUNCTION:
 			case ExecutorTargetType.JOB_FUNCTION:
-				sp.start(`Waiting for function execution ${operationReference}...`);
+				sp?.start(`Waiting for function execution ${operationReference}...`);
 				try {
+					let functionStatus;
 					while (true) {
-						const { execution } = await client.getFunctionExecution({
-							workspaceId,
-							executionId: operationReference
-						});
-						if (!execution) throw new Error(`Function execution '${operationReference}' not found.`);
-						if (isFunctionExecutionTerminalStatus(execution.status)) {
-							const statusStr = functionExecutionStatusToString(execution.status);
-							const coloredFnStatus = colorizeFunctionExecutionStatus(statusStr);
-							if (execution.status === FunctionExecution_Status.SUCCESS) sp.succeed(`Function execution completed: ${coloredFnStatus}`);
-							else sp.fail(`Function execution completed: ${coloredFnStatus}`);
-							return {
+						const functionTimeout = remainingTimeout();
+						if (functionTimeout !== void 0 && functionTimeout <= 0) {
+							sp?.fail("Function execution wait timed out.");
+							return withWaitMetadata({
 								job: jobDetail,
 								targetType: targetTypeStr,
 								functionExecutionId: operationReference,
-								functionStatus: statusStr,
-								functionLogs: options.logs ? execution.logs || void 0 : void 0
-							};
+								functionStatus
+							}, true);
 						}
-						sp.text = `Waiting for function execution... (${formatTime(/* @__PURE__ */ new Date())})`;
-						await setTimeout$1(interval);
+						try {
+							attempts += 1;
+							const { execution } = await client.getFunctionExecution({
+								workspaceId,
+								executionId: operationReference
+							});
+							if (!execution) throw new Error(`Function execution '${operationReference}' not found.`);
+							lastError = null;
+							functionStatus = functionExecutionStatusToString(execution.status);
+							if (isFunctionExecutionTerminalStatus(execution.status)) {
+								const coloredFnStatus = colorizeFunctionExecutionStatus(functionStatus);
+								if (execution.status === FunctionExecution_Status.SUCCESS) sp?.succeed(`Function execution completed: ${coloredFnStatus}`);
+								else sp?.fail(`Function execution completed: ${coloredFnStatus}`);
+								return withWaitMetadata({
+									job: jobDetail,
+									targetType: targetTypeStr,
+									functionExecutionId: operationReference,
+									functionStatus,
+									functionLogs: options.logs ? execution.logs || void 0 : void 0
+								}, false);
+							}
+						} catch (error) {
+							if (!isRetryableWaitError(error)) throw error;
+							lastError = formatWaitError(error);
+							if (sp) sp.text = `Retrying function execution poll... (${formatTime(/* @__PURE__ */ new Date())})`;
+						}
+						const nextFunctionTimeout = remainingTimeout();
+						if (nextFunctionTimeout !== void 0 && nextFunctionTimeout <= 0) {
+							sp?.fail("Function execution wait timed out.");
+							return withWaitMetadata({
+								job: jobDetail,
+								targetType: targetTypeStr,
+								functionExecutionId: operationReference,
+								functionStatus
+							}, true);
+						}
+						if (sp) sp.text = `Waiting for function execution... (${formatTime(/* @__PURE__ */ new Date())})`;
+						await setTimeout$1(nextFunctionTimeout === void 0 ? interval : Math.min(interval, nextFunctionTimeout));
 					}
 				} catch (error) {
-					sp.warn(`Could not track function execution: ${error instanceof Error ? error.message : error}`);
-					return {
+					sp?.warn(`Could not track function execution: ${error instanceof Error ? error.message : error}`);
+					return withWaitMetadata({
 						job: jobDetail,
 						targetType: targetTypeStr,
 						functionExecutionId: operationReference
-					};
+					}, false);
 				}
 				break;
 			default: break;
 		}
-		return {
+		return withWaitMetadata({
 			job: jobDetail,
 			targetType: targetTypeStr
-		};
+		}, false);
 	} finally {
-		sp.stop();
+		sp?.stop();
 	}
 }
+/**
+* Build a user-facing failure message for an executor job wait result.
+* @param result - Executor job wait result
+* @returns Failure message, or undefined when the wait succeeded
+*/
+function getExecutorWaitFailureMessage(result) {
+	if (result.timedOut) return `Timed out waiting for executor job '${result.job.id}'. Last status: ${result.job.status}.`;
+	if (result.job.status === "FAILED" || result.job.status === "CANCELED") return `Executor job '${result.job.id}' completed with status ${result.job.status}.`;
+	if (result.workflowStatus === "FAILED") return `Workflow execution '${result.workflowExecutionId}' failed.`;
+	if (result.functionStatus === "FAILED") return `Function execution '${result.functionExecutionId}' failed.`;
+}
 function printJobWithAttempts(job) {
 	const summaryData = [
 		["id", job.id],
@@ -12473,6 +12874,10 @@ const jobsCommand = defineAppCommand({
 			alias: "i",
 			description: "Polling interval when using --wait (e.g., '3s', '500ms', '1m')"
 		}),
+		timeout: arg(durationArg.default("5m"), {
+			alias: "t",
+			description: "Maximum time to wait when using --wait (e.g., '30s', '5m')"
+		}),
 		...pagedLogArgs,
 		limit: arg(nonNegativeIntArg.default(50), { description: "Maximum number of jobs to list (0: unlimited, default: 50) (list mode only)" }),
 		logs: arg(z.boolean().default(false), {
@@ -12481,6 +12886,7 @@ const jobsCommand = defineAppCommand({
 		})
 	}).strict(),
 	run: async (args) => {
+		const jsonOutput = logger.jsonMode || args.json;
 		if (args.jobId) {
 			if (args.wait) {
 				const result = await watchExecutorJob({
@@ -12489,9 +12895,11 @@ const jobsCommand = defineAppCommand({
 					workspaceId: args["workspace-id"],
 					profile: args.profile,
 					interval: parseDuration(args.interval),
-					logs: args.logs
+					timeout: parseDuration(args.timeout),
+					logs: args.logs,
+					showProgress: !jsonOutput
 				});
-				if (!args.json) {
+				if (!jsonOutput) {
 					logger.log(styles.bold(`Target Type: ${result.targetType}\n`));
 					printJobWithAttempts(result.job);
 					if (result.workflowExecutionId) {
@@ -12526,6 +12934,8 @@ const jobsCommand = defineAppCommand({
 						}
 					}
 				} else logger.out(result);
+				const failureMessage = getExecutorWaitFailureMessage(result);
+				if (failureMessage) throw new Error(failureMessage);
 				return;
 			}
 			const job = await getExecutorJob({
@@ -12535,7 +12945,7 @@ const jobsCommand = defineAppCommand({
 				workspaceId: args["workspace-id"],
 				profile: args.profile
 			});
-			if (args.attempts && !args.json) printJobWithAttempts(job);
+			if (args.attempts && !jsonOutput) printJobWithAttempts(job);
 			else logger.out(job);
 		} else {
 			if (args.wait) logger.warn("--wait flag is ignored in list mode. Specify a job ID to wait.");
@@ -12722,12 +13132,17 @@ The \`--logs\` option displays logs from the downstream execution when available
 			alias: "i",
 			description: "Polling interval when using --wait (e.g., '3s', '500ms', '1m')"
 		}),
+		timeout: arg(durationArg.default("5m"), {
+			alias: "t",
+			description: "Maximum time to wait when using --wait (e.g., '30s', '5m')"
+		}),
 		logs: arg(z.boolean().default(false), {
 			alias: "l",
 			description: "Display function execution logs after completion (requires --wait)"
 		})
 	}).strict(),
 	run: async (args) => {
+		const jsonOutput = logger.jsonMode || args.json;
 		await assertWritable({ profile: args.profile });
 		const client = await initOperatorClient(await loadAccessToken({ profile: args.profile }));
 		const workspaceId = await loadWorkspaceId({
@@ -12768,9 +13183,11 @@ The \`--logs\` option displays logs from the downstream execution when available
 				workspaceId: args["workspace-id"],
 				profile: args.profile,
 				interval: parseDuration(args.interval),
-				logs: args.logs
+				timeout: parseDuration(args.timeout),
+				logs: args.logs,
+				showProgress: !jsonOutput
 			});
-			if (!args.json) {
+			if (!jsonOutput) {
 				logger.log(styles.bold(`\nTarget Type: ${watchResult.targetType}`));
 				logger.log(`Job Status: ${watchResult.job.status}`);
 				if (watchResult.workflowExecutionId) {
@@ -12805,6 +13222,8 @@ The \`--logs\` option displays logs from the downstream execution when available
 					}
 				}
 			} else logger.out(watchResult);
+			const failureMessage = getExecutorWaitFailureMessage(watchResult);
+			if (failureMessage) throw new Error(failureMessage);
 		}
 	}
 });
@@ -15942,11 +16361,13 @@ async function resumeWorkflow(options) {
 		});
 		return {
 			executionId,
-			wait: (waitOptions) => waitForExecution({
+			wait: (waitOptions) => waitForWorkflowExecution({
 				client,
 				workspaceId,
 				executionId,
 				interval: options.interval ?? 3e3,
+				timeout: waitOptions?.timeout,
+				until: waitOptions?.until,
 				showProgress: waitOptions?.showProgress
 			})
 		};
@@ -15970,16 +16391,21 @@ const resumeCommand = defineAppCommand({
 		...waitArgs
 	}).strict(),
 	run: async (args) => {
+		const jsonOutput = logger.jsonMode || args.json;
 		const { executionId, wait } = await resumeWorkflow({
 			executionId: args.executionId,
 			workspaceId: args["workspace-id"],
 			profile: args.profile,
 			interval: parseDuration(args.interval)
 		});
-		if (!args.json) logger.info(`Execution ID: ${executionId}`, { mode: "stream" });
+		if (!jsonOutput) logger.info(`Execution ID: ${executionId}`, { mode: "stream" });
 		if (args.wait) {
-			const result = await wait({ showProgress: !args.json });
-			if (args.logs && !args.json) {
+			const result = await wait({
+				showProgress: !jsonOutput,
+				timeout: parseDuration(args.timeout),
+				until: args.until
+			});
+			if (args.logs && !jsonOutput) {
 				const { execution } = await getWorkflowExecution({
 					executionId,
 					workspaceId: args["workspace-id"],
@@ -15987,11 +16413,112 @@ const resumeCommand = defineAppCommand({
 					logs: true
 				});
 				printExecutionWithLogs(execution);
+			} else if (args.logs) {
+				const { execution } = await getWorkflowExecution({
+					executionId,
+					workspaceId: args["workspace-id"],
+					profile: args.profile,
+					logs: true
+				});
+				logger.out({
+					...result,
+					jobDetails: execution.jobDetails
+				});
 			} else logger.out(result);
+			const failureMessage = getWorkflowWaitFailureMessage(result, args.until);
+			if (failureMessage) throw new Error(failureMessage);
 		} else logger.out({ executionId });
 	}
 });
 
+//#endregion
+//#region src/cli/commands/workflow/wait.ts
+/**
+* Wait for an existing workflow execution by ID.
+* @param options - Workflow wait options
+* @returns Workflow wait result
+*/
+async function waitWorkflowExecution(options) {
+	return await waitForWorkflowExecutionById({
+		...options,
+		showProgress: options.showProgress ?? !logger.jsonMode,
+		trackJobs: options.trackJobs ?? true
+	});
+}
+/**
+* Attach workflow job logs to a wait result when requested.
+* @param result - Workflow wait result
+* @param options - Workflow wait options
+* @returns Workflow wait result with optional job details
+*/
+async function addWorkflowLogsToWaitResult(result, options) {
+	const { execution } = await getWorkflowExecution({
+		executionId: options.executionId,
+		workspaceId: options.workspaceId,
+		profile: options.profile,
+		logs: true
+	});
+	return {
+		...result,
+		jobDetails: execution.jobDetails
+	};
+}
+const waitCommand = defineAppCommand({
+	name: "wait",
+	description: "Wait for a workflow execution.",
+	examples: [
+		{
+			cmd: "execution-id --until success --timeout 10m --json",
+			desc: "Wait for workflow success"
+		},
+		{
+			cmd: "execution-id --until suspended --timeout 6m --logs --json",
+			desc: "Wait for a workflow wait point"
+		},
+		{
+			cmd: "execution-id --until terminal",
+			desc: "Wait for success, failure, or suspension"
+		}
+	],
+	args: z.object({
+		...workspaceArgs,
+		"execution-id": arg(z.string(), {
+			positional: true,
+			description: "Execution ID"
+		}),
+		...workflowWaitControlArgs
+	}).strict(),
+	run: async (args) => {
+		const jsonOutput = logger.jsonMode || args.json;
+		const result = await waitWorkflowExecution({
+			executionId: args.executionId,
+			workspaceId: args["workspace-id"],
+			profile: args.profile,
+			interval: parseDuration(args.interval),
+			timeout: parseDuration(args.timeout),
+			until: args.until,
+			showProgress: !jsonOutput
+		});
+		const output = args.logs ? await addWorkflowLogsToWaitResult(result, {
+			executionId: args.executionId,
+			workspaceId: args["workspace-id"],
+			profile: args.profile
+		}) : result;
+		if (!jsonOutput && output.jobDetails) printExecutionWithLogs({
+			id: output.id,
+			workflowName: output.workflowName,
+			status: output.status,
+			jobExecutions: output.jobExecutions,
+			startedAt: output.startedAt,
+			finishedAt: output.finishedAt,
+			jobDetails: output.jobDetails
+		});
+		else logger.out(output);
+		const failureMessage = getWorkflowWaitFailureMessage(result, args.until);
+		if (failureMessage) throw new Error(failureMessage);
+	}
+});
+
 //#endregion
 //#region src/cli/commands/workspace/app/transform.ts
 const statusToString = (status) => {
@@ -17669,5 +18196,5 @@ function isDeno() {
 }
 
 //#endregion
-export { listCommand$5 as $, INITIAL_SCHEMA_NUMBER as $t, truncate as A, commonArgs as An, startCommand as At, logBetaWarning as B, getExecutor as Bt, listCommand$2 as C, PluginManager as Cn, triggerExecutor as Ct, resumeWorkflow as D, apiCall as Dn, jobsCommand as Dt, resumeCommand as E, apiCommand as En, getExecutorJob as Et, writeDbTypesFile as F, pagedLogArgs as Fn, getWorkflowExecution as Ft, organizationTree as G, MIGRATION_LABEL_KEY as Gt, removeCommand$1 as H, executeScript as Ht, getConfiguredEditorCommand as I, paginationArgs as In, listWorkflowExecutions as It, listOrganizations as J, compareSnapshotWithRemote as Jt, treeCommand as K, handleOptionalToRequiredError as Kt, openInConfiguredEditor as L, toPageDirection as Ln, functionExecutionStatusToString as Lt, generate as M, confirmationArgs as Mn, getCommand$5 as Mt, generateCommand as N, deploymentArgs as Nn, getWorkflow as Nt, listCommand$3 as O, assertWritable as On, listExecutorJobs as Ot, generateMigrationScript as P, isVerbose as Pn, executionsCommand as Pt, updateFolder as Q, DIFF_FILE_NAME as Qt, show as R, workspaceArgs as Rn, formatKeyValueTable as Rt, listApps as S, sdkNameLabelKey as Sn, triggerCommand as St, healthCommand as T, prompt as Tn, listExecutors as Tt, updateCommand$1 as U, waitForExecution$1 as Ut, remove as V, deploy as Vt, updateOrganization as W, bundleMigrationScript as Wt, getOrganization as X, protoGqlPermission as Xt, getCommand$1 as Y, generateAllTypeManifestsFromSnapshot as Yt, updateCommand$2 as Z, DB_TYPES_FILE_NAME as Zt, getWorkspace as _, formatMigrationDiff as _n, listFunctionRegistries as _t, updateUser as a, createSnapshotFromLocalTypes as an, createCommand$1 as at, createCommand as b, ensureConfigId as bn, listWebhookExecutors as bt, listCommand as c, getMigrationFilePath as cn, listOAuth2Clients as ct, inviteUser as d, isValidMigrationNumber as dn, getMachineUserToken as dt, MIGRATE_FILE_NAME as en, listFolders as et, restoreCommand as f, loadDiff as fn, tokenCommand as ft, getCommand as g, formatDiffSummary as gn, listCommand$8 as gt, listWorkspaces as h, parseMigrationNumberArg as hn, generate$1 as ht, updateCommand as i, compareSnapshots as in, deleteFolder as it, truncateCommand as j, configArg as jn, startWorkflow as jt, listWorkflows as k, defineAppCommand as kn, watchExecutorJob as kt, listUsers as l, getMigrationFiles as ln, getCommand$3 as lt, listCommand$1 as m, formatMigrationNumber as mn, listMachineUsers as mt, query as n, assertValidMigrationFiles as nn, getFolder as nt, removeCommand as o, getLatestMigrationNumber as on, createFolder as ot, restoreWorkspace as p, reconstructSnapshotFromMigrations as pn, listCommand$7 as pt, listCommand$4 as q, parseMigrationLabelNumber as qt, queryCommand as r, compareLocalTypesWithSnapshot as rn, deleteCommand$1 as rt, removeUser as s, getMigrationDirPath as sn, listCommand$6 as st, isNativeTypeScriptRuntime as t, SCHEMA_FILE_NAME as tn, getCommand$2 as tt, inviteCommand as u, getNextMigrationNumber as un, getOAuth2Client as ut, deleteCommand as v, hasChanges as vn, getCommand$4 as vt, getAppHealth as w, generateUserTypes as wn, listCommand$9 as wt, createWorkspace as x, resourceTrn as xn, webhookCommand as xt, deleteWorkspace as y, getNamespacesWithMigrations as yn, getFunctionRegistry as yt, showCommand as z, getCommand$6 as zt };
-//# sourceMappingURL=runtime-BU6KtCvk.mjs.map
+export { updateCommand$2 as $, protoGqlPermission as $t, listCommand$3 as A, apiCall as An, jobsCommand as At, show as B, toPageDirection as Bn, functionExecutionStatusToString as Bt, listCommand$2 as C, ensureConfigId as Cn, webhookCommand as Ct, waitWorkflowExecution as D, generateUserTypes as Dn, listExecutors as Dt, waitCommand as E, PluginManager as En, listCommand$9 as Et, generateCommand as F, confirmationArgs as Fn, getCommand$5 as Ft, updateCommand$1 as G, executeScript as Gt, logBetaWarning as H, getCommand$6 as Ht, generateMigrationScript as I, deploymentArgs as In, getWorkflow as It, treeCommand as J, MIGRATION_LABEL_KEY as Jt, updateOrganization as K, waitForExecution as Kt, writeDbTypesFile as L, isVerbose as Ln, executionsCommand as Lt, truncate as M, defineAppCommand as Mn, watchExecutorJob as Mt, truncateCommand as N, commonArgs as Nn, startCommand as Nt, resumeCommand as O, prompt as On, getExecutorJob as Ot, generate as P, configArg as Pn, startWorkflow as Pt, getOrganization as Q, generateAllTypeManifestsFromSnapshot as Qt, getConfiguredEditorCommand as R, pagedLogArgs as Rn, getWorkflowExecution as Rt, listApps as S, getNamespacesWithMigrations as Sn, listWebhookExecutors as St, healthCommand as T, sdkNameLabelKey as Tn, triggerExecutor as Tt, remove as U, getExecutor as Ut, showCommand as V, workspaceArgs as Vn, formatKeyValueTable as Vt, removeCommand$1 as W, deploy as Wt, listOrganizations as X, parseMigrationLabelNumber as Xt, listCommand$4 as Y, handleOptionalToRequiredError as Yt, getCommand$1 as Z, compareSnapshotWithRemote as Zt, getWorkspace as _, formatMigrationNumber as _n, generate$1 as _t, updateUser as a, assertValidMigrationFiles as an, deleteCommand$1 as at, createCommand as b, formatMigrationDiff as bn, getCommand$4 as bt, listCommand as c, createSnapshotFromLocalTypes as cn, createFolder as ct, inviteUser as d, getMigrationFilePath as dn, getCommand$3 as dt, DB_TYPES_FILE_NAME as en, updateFolder as et, restoreCommand as f, getMigrationFiles as fn, getOAuth2Client as ft, getCommand as g, reconstructSnapshotFromMigrations as gn, listMachineUsers as gt, listWorkspaces as h, loadDiff as hn, listCommand$7 as ht, updateCommand as i, SCHEMA_FILE_NAME as in, getFolder as it, listWorkflows as j, assertWritable as jn, listExecutorJobs as jt, resumeWorkflow as k, apiCommand as kn, getExecutorWaitFailureMessage as kt, listUsers as l, getLatestMigrationNumber as ln, listCommand$6 as lt, listCommand$1 as m, isValidMigrationNumber as mn, tokenCommand as mt, query as n, INITIAL_SCHEMA_NUMBER as nn, listFolders as nt, removeCommand as o, compareLocalTypesWithSnapshot as on, deleteFolder as ot, restoreWorkspace as p, getNextMigrationNumber as pn, getMachineUserToken as pt, organizationTree as q, bundleMigrationScript as qt, queryCommand as r, MIGRATE_FILE_NAME as rn, getCommand$2 as rt, removeUser as s, compareSnapshots as sn, createCommand$1 as st, isNativeTypeScriptRuntime as t, DIFF_FILE_NAME as tn, listCommand$5 as tt, inviteCommand as u, getMigrationDirPath as un, listOAuth2Clients as ut, deleteCommand as v, parseMigrationNumberArg as vn, listCommand$8 as vt, getAppHealth as w, resourceTrn as wn, triggerCommand as wt, createWorkspace as x, hasChanges as xn, getFunctionRegistry as xt, deleteWorkspace as y, formatDiffSummary as yn, listFunctionRegistries as yt, openInConfiguredEditor as z, paginationArgs as zn, listWorkflowExecutions as zt };
+//# sourceMappingURL=runtime-DxaBq6U8.mjs.map