@keystrokehq/cli 0.0.1

package/dist/workflows-g9z87AJJ.mjs

@@ -0,0 +1,799 @@
+#!/usr/bin/env node
+
+import { n as JsonOptionSchema, t as JSON_OPTION_CONFIG } from "./output-DM4b7KgY.mjs";
+import { t as createTypedCommand } from "./commander-DfTVqQ-3.mjs";
+import { V as SHA256HashSchema, p as TriggerUploadDataSchema, z as JsonSchemaSchema } from "./schedule-BXx3uXwr.mjs";
+import { c as FlowGraphSchema, s as WorkflowManifestSchema } from "./_manifest-JSRE3H8k.mjs";
+import { n as WorkflowsRunOptionsSchema, t as RUN_OPTIONS_CONFIG } from "./options-CeaTcFxP.mjs";
+import { z } from "zod";
+const GitProviderSchema = z.enum(["codestorage", "github"]);
+const GitTreeEntryTypeSchema = z.enum(["file", "directory"]);
+const GitFileEditActionSchema = z.enum([
+	"create",
+	"update",
+	"delete"
+]);
+z.object({
+	id: z.string().min(1),
+	cloneUrl: z.string().min(1),
+	defaultBranch: z.string().min(1).default("main")
+});
+z.object({
+	path: z.string().min(1),
+	type: GitTreeEntryTypeSchema,
+	sizeBytes: z.number().int().nonnegative().optional()
+});
+z.object({
+	path: z.string().min(1),
+	content: z.string()
+});
+const GitFileEditSchema = z.object({
+	path: z.string().min(1),
+	action: GitFileEditActionSchema,
+	content: z.string().optional()
+});
+const GitCommitAuthorSchema = z.object({
+	name: z.string().min(1),
+	email: z.email()
+});
+z.object({
+	organizationId: z.string().min(1),
+	projectId: z.string().min(1),
+	repoName: z.string().min(1)
+});
+z.object({
+	branch: z.string().min(1).default("main"),
+	message: z.string().min(1),
+	author: GitCommitAuthorSchema,
+	edits: z.array(GitFileEditSchema).min(1)
+});
+z.object({
+	sha: z.string().min(1),
+	branch: z.string().min(1)
+});
+z.object({
+	branch: z.string().min(1).optional(),
+	limit: z.number().int().positive().max(200).optional()
+});
+z.object({
+	sha: z.string().min(1),
+	message: z.string().min(1),
+	authoredAt: z.string().min(1),
+	author: GitCommitAuthorSchema
+});
+z.object({
+	cloneUrl: z.string().min(1),
+	expiresAt: z.string().optional().nullable()
+});
+z.object({
+	tag: z.string().min(1),
+	commitSha: z.string().min(1)
+});
+z.uuid();
+const ProjectBaseSchema = z.object({
+	organizationId: z.uuid(),
+	name: z.string().min(1).max(255),
+	description: z.string().optional().nullable(),
+	isDefault: z.boolean().default(false),
+	githubRepoUrl: z.url().optional().nullable(),
+	gitRepoId: z.string().optional().nullable(),
+	gitProvider: GitProviderSchema.optional().nullable()
+});
+ProjectBaseSchema.extend({
+	id: z.uuid(),
+	currentDeploymentId: z.string().optional().nullable(),
+	createdBy: z.uuid().optional().nullable(),
+	createdAt: z.date(),
+	updatedAt: z.date(),
+	deletedAt: z.date().optional().nullable()
+});
+z.enum([
+	"active",
+	"hibernated",
+	"creating",
+	"error",
+	"deleted"
+]);
+const ActivationStatusSchema = z.enum([
+	"active",
+	"paused",
+	"disabled"
+]);
+z.enum(["automatic", "requires_activation"]);
+z.enum(["workflow", "task"]);
+const activationSharedFields = {
+	id: z.string(),
+	projectId: z.uuid(),
+	organizationId: z.uuid(),
+	logicalTriggerKey: z.string(),
+	status: ActivationStatusSchema,
+	/**
+	* Per-callback trigger credential bindings.
+	* Key: "<callbackName>:<credentialSetResolvedId>" (e.g. "verify:keystroke:slack").
+	* Value: credential set ID or "<scope>.default".
+	*/
+	triggerCredentialBindings: z.record(z.string(), z.string()).optional(),
+	/**
+	* Per-step workflow credential bindings (workflow-target only).
+	* Key: "<stepNodeId>:<credentialSetResolvedId>" (e.g. "step_1:keystroke:slack").
+	* Value: credential set ID or "<scope>.default".
+	*/
+	workflowCredentialBindings: z.record(z.string(), z.string()).optional(),
+	config: z.unknown().optional(),
+	state: z.unknown().optional(),
+	nextRunAt: z.string().datetime().nullable(),
+	lastRunAt: z.string().datetime().nullable(),
+	createdAt: z.string().datetime(),
+	updatedAt: z.string().datetime(),
+	deletedAt: z.string().datetime().nullable()
+};
+const WorkflowActivationSchema = z.object({
+	...activationSharedFields,
+	targetKind: z.literal("workflow"),
+	workflowId: z.uuid(),
+	taskId: z.null(),
+	userId: z.uuid().nullable()
+});
+const TaskActivationSchema = z.object({
+	...activationSharedFields,
+	targetKind: z.literal("task"),
+	taskId: z.string(),
+	workflowId: z.null(),
+	userId: z.null()
+});
+z.discriminatedUnion("targetKind", [WorkflowActivationSchema, TaskActivationSchema]);
+z.object({
+	id: z.string(),
+	projectId: z.uuid(),
+	activationId: z.string(),
+	idempotencyKey: z.string(),
+	createdAt: z.string().datetime(),
+	expiresAt: z.string().datetime()
+});
+//#endregion
+//#region ../../packages/shared-types/src/workflows/domain/log.ts
+const LogLevelSchema = z.enum([
+	"debug",
+	"info",
+	"warn",
+	"error"
+]);
+const LogSourceSchema = z.enum([
+	"system",
+	"workflow",
+	"step"
+]);
+z.object({
+	level: LogLevelSchema,
+	source: LogSourceSchema,
+	message: z.string(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	timestamp: z.iso.datetime(),
+	correlationId: z.string().optional()
+});
+//#endregion
+//#region ../../packages/shared-types/src/workflows/domain/reactflow-edit.ts
+/** A user-initiated node drag that changes its canvas position. */
+const MoveNodeMutationSchema = z.object({
+	kind: z.literal("move-node"),
+	nodeId: z.string().min(1),
+	x: z.number().finite(),
+	y: z.number().finite()
+});
+const WorkflowMutationSchema = z.discriminatedUnion("kind", [MoveNodeMutationSchema]);
+z.enum([
+	"active",
+	"paused",
+	"disabled",
+	"archived"
+]);
+const WorkflowBaseSchema = z.object({
+	organizationId: z.uuid(),
+	projectId: z.uuid(),
+	name: z.string().min(1).max(255),
+	description: z.string().optional().nullable(),
+	tags: z.array(z.string()).optional().nullable(),
+	icon: z.string().max(50).optional().nullable(),
+	isArchived: z.boolean().default(false)
+});
+WorkflowBaseSchema.extend({
+	authoredWorkflowId: z.string().min(1),
+	createdBy: z.uuid().optional().nullable(),
+	updatedBy: z.uuid().optional().nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	deletedAt: z.string().optional().nullable()
+});
+const NewWorkflowSchema = WorkflowBaseSchema;
+const StepBaseSchema = z.object({
+	organizationId: z.uuid(),
+	projectId: z.uuid(),
+	name: z.string().min(1).max(255),
+	slug: z.string().min(1).max(255).regex(/^[a-z0-9-]+$/, "Slug must be alphanumeric and can contain hyphens"),
+	description: z.string().optional().nullable(),
+	tags: z.array(z.string()).optional().nullable(),
+	icon: z.string().max(50).optional().nullable(),
+	credentialSets: z.array(z.string()).default([]),
+	isArchived: z.boolean().default(false)
+});
+StepBaseSchema.extend({
+	id: z.string().startsWith("sdef_"),
+	createdBy: z.uuid().optional().nullable(),
+	updatedBy: z.uuid().optional().nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	deletedAt: z.string().optional().nullable()
+});
+const NewStepSchema = StepBaseSchema;
+z.object({
+	stepId: z.string().startsWith("sdef_"),
+	version: z.number().int().positive(),
+	storagePath: z.string().max(1024).optional().nullable(),
+	sourceCode: z.string(),
+	exportName: z.string().min(1).max(255),
+	inputSchema: JsonSchemaSchema.optional().nullable(),
+	outputSchema: JsonSchemaSchema.optional().nullable(),
+	credentialSets: z.array(z.unknown()).default([]),
+	timeout: z.string().max(50).optional().nullable(),
+	retryConfig: JsonSchemaSchema.optional().nullable(),
+	isLatest: z.boolean().default(false),
+	isDeprecated: z.boolean().default(false)
+}).extend({
+	id: z.string().startsWith("sdv_"),
+	publishedBy: z.uuid().optional().nullable(),
+	publishedAt: z.string(),
+	createdAt: z.string()
+});
+z.object({
+	limit: z.number(),
+	offset: z.number(),
+	total: z.number()
+});
+/**
+* Pagination query parameters for list endpoints.
+* Uses consistent validation across all endpoints:
+* - limit: 1-100 (default: 20)
+* - offset: >= 0 (default: 0)
+*/
+const PaginationQuerySchema = z.object({
+	limit: z.coerce.number().min(1).max(100).optional().default(20),
+	offset: z.coerce.number().min(0).optional().default(0)
+});
+z.object({
+	error: z.string(),
+	message: z.string().optional(),
+	code: z.string().optional()
+});
+z.object({
+	error: z.literal("Not found"),
+	resource: z.string(),
+	id: z.string()
+});
+z.object({
+	error: z.literal("Validation failed"),
+	message: z.string(),
+	fields: z.record(z.string(), z.array(z.string())).optional()
+});
+/** Matches UUID v1-v5 format. Used to distinguish UUIDs from slugs at runtime. */
+const UUID_FORMAT = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+z.string().min(1).max(255).regex(/^[a-z0-9-]+$/, "Slug must be alphanumeric and can contain hyphens").refine((val) => !UUID_FORMAT.test(val), "Slug must not be in UUID format");
+//#endregion
+//#region src/commands/workflows/build.command.ts
+const WorkflowsBuildOptionsSchema = z.object({
+	path: z.string().optional(),
+	verbose: z.boolean().default(false),
+	name: z.string().optional(),
+	target: z.array(z.string()).default([]),
+	force: z.boolean().default(false),
+	disableSourcemaps: z.boolean().default(false)
+});
+const BUILD_OPTIONS_CONFIG = {
+	path: {
+		flag: "--path <path>",
+		description: "Path to project root (directory containing keystroke.config.ts); auto-discovered from CWD if omitted"
+	},
+	verbose: {
+		flag: "--verbose",
+		description: "Show detailed build logs"
+	},
+	name: {
+		flag: "--name <workflow>",
+		description: "Build only one workflow by exact workflow name"
+	},
+	target: {
+		flag: "--target <file>",
+		description: "Build deployable exports from a target source file; repeat for multiple files",
+		collect: true
+	},
+	force: {
+		flag: "--force",
+		description: "Build all workflows regardless of cache"
+	},
+	disableSourcemaps: {
+		flag: "--disable-sourcemaps",
+		description: "Disable sourcemap generation for build bundles"
+	}
+};
+function createWorkflowsBuildCommand() {
+	return createTypedCommand({
+		name: "build",
+		description: "Build workflows locally",
+		schema: WorkflowsBuildOptionsSchema,
+		optionsConfig: BUILD_OPTIONS_CONFIG,
+		loadHandler: async () => (await import("./build.handler-4799CjWH.mjs")).handleWorkflowsBuild
+	});
+}
+//#endregion
+//#region src/commands/workflows/diff/diff.command.ts
+const WorkflowsDiffOptionsSchema = JsonOptionSchema.extend({
+	workflow: z.string(),
+	path: z.string().optional()
+});
+const DIFF_OPTIONS_CONFIG = {
+	...JSON_OPTION_CONFIG,
+	path: {
+		flag: "--path <dir>",
+		description: "Path to project root; auto-discovered from CWD if omitted"
+	}
+};
+function createWorkflowsDiffCommand() {
+	return createTypedCommand({
+		name: "diff",
+		description: "Compare local workflow definition against the current project deployment",
+		schema: WorkflowsDiffOptionsSchema,
+		optionsConfig: DIFF_OPTIONS_CONFIG,
+		argument: {
+			name: "workflow",
+			description: "Authored workflow id (preferred) or workflow name",
+			key: "workflow"
+		},
+		loadHandler: async () => (await import("./diff.handler-Du7SY8K4.mjs")).handleWorkflowsDiff
+	});
+}
+//#endregion
+//#region src/commands/workflows/env/env.command.ts
+const WorkflowsEnvOptionsSchema = JsonOptionSchema.extend({
+	workflow: z.string().optional(),
+	path: z.string().optional(),
+	check: z.boolean().optional().default(false)
+});
+const ENV_OPTIONS_CONFIG = {
+	...JSON_OPTION_CONFIG,
+	path: {
+		flag: "--path <dir>",
+		description: "Path to project root; auto-discovered from CWD if omitted"
+	},
+	check: {
+		flag: "--check",
+		description: "Exit non-zero if any required env var is missing (useful for CI)"
+	}
+};
+function createWorkflowsEnvCommand() {
+	return createTypedCommand({
+		name: "env",
+		description: "Show environment variables and credentials required by a workflow",
+		schema: WorkflowsEnvOptionsSchema,
+		optionsConfig: ENV_OPTIONS_CONFIG,
+		argument: {
+			name: "workflow",
+			description: "Authored workflow id (preferred) or workflow name — omit to show all",
+			key: "workflow",
+			required: false
+		},
+		loadHandler: async () => (await import("./env.handler-BAzBuMzQ.mjs")).handleWorkflowsEnv
+	});
+}
+//#endregion
+//#region src/commands/workflows/inspect/inspect.command.ts
+const WorkflowsInspectOptionsSchema = JsonOptionSchema.extend({
+	workflow: z.string(),
+	path: z.string().optional(),
+	deployed: z.boolean().optional().default(false)
+});
+const INSPECT_OPTIONS_CONFIG = {
+	...JSON_OPTION_CONFIG,
+	path: {
+		flag: "--path <dir>",
+		description: "Path to project root; auto-discovered from CWD if omitted"
+	},
+	deployed: {
+		flag: "--deployed",
+		description: "Fetch manifest from the current deployment for this project"
+	}
+};
+function createWorkflowsInspectCommand() {
+	return createTypedCommand({
+		name: "inspect",
+		description: "Show the full manifest for a workflow (schemas, steps, credentials)",
+		schema: WorkflowsInspectOptionsSchema,
+		optionsConfig: INSPECT_OPTIONS_CONFIG,
+		argument: {
+			name: "workflow",
+			description: "Authored workflow id (preferred) or workflow name",
+			key: "workflow"
+		},
+		loadHandler: async () => (await import("./inspect.handler-DT_cD036.mjs")).handleWorkflowsInspect
+	});
+}
+//#endregion
+//#region src/commands/workflows/logs/logs.command.ts
+const LogsLevelOptionSchema = z.enum([
+	"debug",
+	"info",
+	"warn",
+	"error"
+]);
+const WorkflowsLogsOptionsSchema = JsonOptionSchema.extend({
+	workflow: z.string().optional(),
+	runId: z.string().optional(),
+	latest: z.boolean().optional().default(false),
+	limit: z.coerce.number().int().min(1).max(100).default(10),
+	status: z.string().optional(),
+	level: LogsLevelOptionSchema.optional(),
+	tail: z.coerce.number().int().min(1).max(200).optional(),
+	follow: z.boolean().optional().default(false),
+	verbose: z.boolean().optional().default(false)
+}).superRefine((value, ctx) => {
+	const logMode = value.latest || value.runId !== void 0;
+	if (!value.workflow && !value.runId) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["workflow"],
+		message: "Provide an authored workflow id or a workflow name, or use --run-id <id> to inspect a specific run."
+	});
+	if (value.latest && value.runId) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["latest"],
+		message: "Use either --latest or --run-id, not both."
+	});
+	if (value.latest && !value.workflow) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["workflow"],
+		message: "--latest requires an authored workflow id or a workflow name."
+	});
+	if (value.status && logMode) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["status"],
+		message: "--status only applies when listing runs."
+	});
+	if ((value.level || value.tail || value.follow) && !logMode) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["runId"],
+		message: "--level, --tail, and --follow require --latest or --run-id."
+	});
+});
+const LOGS_OPTIONS_CONFIG = {
+	...JSON_OPTION_CONFIG,
+	runId: {
+		flag: "--run-id <runId>",
+		description: "Show logs for a specific run ID"
+	},
+	latest: {
+		flag: "--latest",
+		description: "Show logs for the latest run of the specified workflow"
+	},
+	limit: {
+		flag: "--limit <n>",
+		description: "List mode only: max runs to display (default: 10)"
+	},
+	status: {
+		flag: "--status <status>",
+		description: "List mode only: filter runs by status (pending/running/completed/failed/cancelled)"
+	},
+	level: {
+		flag: "--level <level>",
+		description: "Log mode only: filter log lines by level (debug/info/warn/error)"
+	},
+	tail: {
+		flag: "--tail <n>",
+		description: "Log mode only: show only the last N fetched log lines (max: 200)"
+	},
+	follow: {
+		flag: "--follow",
+		description: "Log mode only: poll for new logs until the selected run reaches a terminal state"
+	},
+	verbose: {
+		flag: "--verbose",
+		description: "Include log metadata in output"
+	}
+};
+function createWorkflowsLogsCommand() {
+	return createTypedCommand({
+		name: "logs",
+		description: "List recent runs for a workflow id or name, or show logs for the latest or a specific run",
+		schema: WorkflowsLogsOptionsSchema,
+		optionsConfig: LOGS_OPTIONS_CONFIG,
+		argument: {
+			name: "workflow",
+			description: "Authored workflow id (preferred) or workflow name",
+			key: "workflow",
+			required: false
+		},
+		loadHandler: async () => (await import("./logs.handler-BD_dXiL1.mjs")).handleWorkflowsLogs
+	});
+}
+//#endregion
+//#region ../../packages/shared-types/src/workflows/api/request.ts
+/** Key format: <stepNodeId>:<credentialSetResolvedId> (e.g. step_1:keystroke:slack)
+* The resolved ID may contain a colon for namespaced IDs (e.g. keystroke:slack) */
+const WORKFLOW_CREDENTIAL_BINDING_KEY_REGEX = /^[a-zA-Z0-9_]+:[a-zA-Z0-9.:_-]+$/;
+/** Key format: <callbackName>:<credentialSetResolvedId> (e.g. verify:keystroke:slack) */
+const TRIGGER_CREDENTIAL_BINDING_KEY_REGEX = /^(verify|filter|transform|idempotencyKey|callback):[a-zA-Z0-9.:_-]+$/;
+/** Value: credential set ID (cset_ + ULID) or <scope>.default */
+const CREDENTIAL_BINDING_VALUE_CREDSET = /^cset_[A-Za-z0-9]{26}$/;
+const CREDENTIAL_BINDING_VALUE_SCOPE_DEFAULT = /^(organization|user|project)\.default$/;
+const WorkflowCredentialBindingsRecordSchema = z.record(z.string(), z.string()).refine((record) => {
+	for (const [key, value] of Object.entries(record)) {
+		if (!WORKFLOW_CREDENTIAL_BINDING_KEY_REGEX.test(key)) return false;
+		if (!CREDENTIAL_BINDING_VALUE_CREDSET.test(value) && !CREDENTIAL_BINDING_VALUE_SCOPE_DEFAULT.test(value)) return false;
+	}
+	return true;
+}, { message: "workflowCredentialBindings keys must be \"<stepNodeId>:<credentialSetResolvedId>\"; values must be credential set ID (cset_...) or \"<scope>.default\"" }).optional();
+const TriggerCredentialBindingsRecordSchema = z.record(z.string(), z.string()).refine((record) => {
+	for (const [key, value] of Object.entries(record)) {
+		if (!TRIGGER_CREDENTIAL_BINDING_KEY_REGEX.test(key)) return false;
+		if (!CREDENTIAL_BINDING_VALUE_CREDSET.test(value) && !CREDENTIAL_BINDING_VALUE_SCOPE_DEFAULT.test(value)) return false;
+	}
+	return true;
+}, { message: "triggerCredentialBindings keys must be \"<callbackName>:<credentialSetResolvedId>\"; values must be credential set ID (cset_...) or \"<scope>.default\"" }).optional();
+z.object({
+	workflowName: z.string().min(1),
+	args: z.array(z.unknown()).optional().default([]),
+	/** Organization ID is required for multi-tenant isolation */
+	organizationId: z.string().min(1),
+	/** User ID for user scope credential resolution (optional) */
+	userId: z.string().optional(),
+	/**
+	* Explicit credential bindings: maps credential set resolved ID to credential set ID.
+	* When specified, uses the given credential set instead of the default.
+	* Example: { "keystroke:slack": "cset_abc123", "keystroke:anthropic": "cset_def456" }
+	*/
+	credentials: z.record(z.string(), z.string()).optional()
+});
+PaginationQuerySchema.extend({
+	authoredWorkflowId: z.string().optional(),
+	workflowName: z.string().optional(),
+	status: z.string().optional()
+}).strict();
+const PausedRunTypeSchema = z.enum(["wait", "hook"]);
+PaginationQuerySchema.extend({
+	authoredWorkflowId: z.string().optional(),
+	workflowName: z.string().optional(),
+	type: PausedRunTypeSchema.optional()
+});
+z.object({ id: z.string().min(1) });
+z.object({ runId: z.string().min(1) });
+z.object({
+	runId: z.string().min(1),
+	correlationId: z.string().min(1)
+});
+z.object({
+	runId: z.string().min(1),
+	correlationId: z.string().min(1)
+});
+z.object({ reason: z.string().optional() });
+z.object({
+	stepId: z.string().min(1).optional(),
+	correlationId: z.string().min(1).optional(),
+	level: LogLevelSchema.optional(),
+	limit: z.coerce.number().int().min(1).max(1e3).optional().default(200),
+	offset: z.coerce.number().int().min(0).optional().default(0)
+}).strict();
+PaginationQuerySchema.extend({
+	projectId: z.union([z.uuid(), z.array(z.uuid())]).optional(),
+	tags: z.union([z.string(), z.array(z.string())]).optional()
+});
+z.object({ id: z.string().min(1) });
+NewWorkflowSchema.omit({ organizationId: true });
+NewWorkflowSchema.omit({ organizationId: true }).partial();
+PaginationQuerySchema.extend({ projectId: z.union([z.uuid(), z.array(z.uuid())]).optional() });
+z.object({ id: z.string().startsWith("sdef_") });
+NewStepSchema.omit({ organizationId: true });
+NewStepSchema.omit({ organizationId: true }).partial();
+z.object({
+	id: z.string().startsWith("sdef_"),
+	version: z.coerce.number().int().positive()
+});
+z.object({
+	activationId: z.string().startsWith("tact_"),
+	args: z.array(z.unknown()).optional().default([]),
+	credentialOverrides: z.record(z.string(), z.string()).optional(),
+	runAsUserId: z.uuid().optional()
+}).strict();
+z.object({
+	projectId: z.uuid(),
+	authoredWorkflowId: z.string().min(1),
+	args: z.array(z.unknown()).optional().default([]),
+	/** Optional credential overrides: maps credential set resolved ID to credential set ID */
+	credentialBindings: z.record(z.string(), z.string()).optional(),
+	workflowGlobals: z.unknown().optional()
+}).strict();
+z.object({
+	workflowName: z.string().min(1),
+	storagePath: z.string().min(1),
+	exportName: z.string().min(1),
+	manifest: WorkflowManifestSchema,
+	flowJson: FlowGraphSchema.optional(),
+	triggers: z.array(TriggerUploadDataSchema).optional(),
+	bundleHash: SHA256HashSchema,
+	bundleSize: z.number(),
+	args: z.array(z.unknown()).optional().default([]),
+	credentialBindings: z.record(z.string(), z.string()).optional(),
+	/** Organization ID from keystroke.config.ts. Required for workflow test. */
+	organizationId: ProjectBaseSchema.shape.organizationId,
+	/** Project UUID from keystroke.config.ts. Required for workflow test. */
+	projectId: z.uuid()
+}).strict();
+z.object({ storagePath: z.string().min(1) }).strict();
+PaginationQuerySchema.extend({
+	logicalTriggerKey: z.string().optional(),
+	status: ActivationStatusSchema.optional()
+});
+z.object({
+	allowed: z.boolean(),
+	required: z.boolean(),
+	reason: z.string().optional()
+});
+z.object({
+	id: z.uuid(),
+	activationId: z.string().startsWith("tact_")
+});
+z.object({
+	workflowId: z.string().uuid(),
+	logicalTriggerKey: z.string().min(1),
+	status: ActivationStatusSchema.optional(),
+	userId: z.uuid().nullable().optional(),
+	workflowCredentialBindings: WorkflowCredentialBindingsRecordSchema,
+	triggerCredentialBindings: TriggerCredentialBindingsRecordSchema,
+	config: z.unknown().optional(),
+	workflowGlobals: z.unknown().optional(),
+	state: z.unknown().optional(),
+	nextRunAt: z.string().datetime().nullable().optional()
+}).strict();
+z.object({
+	status: ActivationStatusSchema.optional(),
+	userId: z.uuid().nullable().optional(),
+	workflowCredentialBindings: WorkflowCredentialBindingsRecordSchema,
+	triggerCredentialBindings: TriggerCredentialBindingsRecordSchema,
+	config: z.unknown().optional(),
+	workflowGlobals: z.unknown().optional(),
+	state: z.unknown().optional(),
+	nextRunAt: z.string().datetime().nullable().optional()
+}).strict();
+z.object({
+	status: z.enum(["active", "paused"]).optional(),
+	workflowCredentialBindings: WorkflowCredentialBindingsRecordSchema,
+	triggerCredentialBindings: TriggerCredentialBindingsRecordSchema,
+	config: z.unknown().optional(),
+	workflowGlobals: z.unknown().optional(),
+	state: z.unknown().optional(),
+	nextRunAt: z.string().datetime().nullable().optional()
+}).strict();
+z.object({ mutations: z.array(WorkflowMutationSchema).min(1) });
+//#endregion
+//#region src/commands/workflows/paused/paused.command.ts
+const WorkflowsPausedOptionsSchema = JsonOptionSchema.extend({
+	workflow: z.string().optional(),
+	type: PausedRunTypeSchema.optional(),
+	limit: z.coerce.number().int().min(1).max(100).default(20)
+});
+const PAUSED_OPTIONS_CONFIG = {
+	...JSON_OPTION_CONFIG,
+	type: {
+		flag: "--type <type>",
+		description: "Filter paused runs to active waits or hooks"
+	},
+	limit: {
+		flag: "--limit <n>",
+		description: "Maximum paused runs to display (default: 20)"
+	}
+};
+function createWorkflowsPausedCommand() {
+	return createTypedCommand({
+		name: "paused",
+		description: "List workflow runs paused on active waits or hooks",
+		schema: WorkflowsPausedOptionsSchema,
+		optionsConfig: PAUSED_OPTIONS_CONFIG,
+		argument: {
+			name: "workflow",
+			description: "Optional authored workflow id or workflow name",
+			key: "workflow",
+			required: false
+		},
+		loadHandler: async () => (await import("./paused.handler-BMFm9Cff.mjs")).handleWorkflowsPaused
+	});
+}
+//#endregion
+//#region src/commands/workflows/try-deploy.command.ts
+function createWorkflowsTryDeployCommand() {
+	return createTypedCommand({
+		name: "try-deploy",
+		description: "Build, upload, and run a workflow on the server",
+		schema: WorkflowsRunOptionsSchema,
+		optionsConfig: RUN_OPTIONS_CONFIG,
+		argument: {
+			name: "workflow",
+			description: "Authored workflow id (preferred) or workflow name. Multiple workflows with the same name run sequentially.",
+			key: "workflow"
+		},
+		loadHandler: async () => (await import("./try-deploy.handler-DqybNhXx.mjs").then((n) => n.n)).handleWorkflowsTryDeploy
+	});
+}
+//#endregion
+//#region src/commands/workflows/validate/validate.command.ts
+const WorkflowsValidateOptionsSchema = JsonOptionSchema.extend({
+	workflow: z.string().optional(),
+	path: z.string().optional(),
+	verbose: z.boolean().optional().default(false),
+	typecheck: z.boolean().default(true)
+});
+const VALIDATE_OPTIONS_CONFIG = {
+	...JSON_OPTION_CONFIG,
+	path: {
+		flag: "--path <dir>",
+		description: "Path to project root; auto-discovered from CWD if omitted"
+	},
+	verbose: {
+		flag: "--verbose",
+		description: "Show detailed validation logs"
+	},
+	typecheck: {
+		flag: "--no-typecheck",
+		description: "Deprecated no-op retained for validate command compatibility"
+	}
+};
+function createWorkflowsValidateCommand() {
+	return createTypedCommand({
+		name: "validate",
+		description: "Run static analysis and type-checking on workflows without building",
+		schema: WorkflowsValidateOptionsSchema,
+		optionsConfig: VALIDATE_OPTIONS_CONFIG,
+		argument: {
+			name: "workflow",
+			description: "Authored workflow id (preferred) or workflow name — omit to validate all",
+			key: "workflow",
+			required: false
+		},
+		loadHandler: async () => (await import("./validate.handler-DOcTaJL0.mjs")).handleWorkflowsValidate
+	});
+}
+//#endregion
+//#region src/commands/workflows/workflows.command.ts
+const WorkflowsOptionsSchema = JsonOptionSchema.extend({ path: z.string().optional() });
+const WORKFLOWS_OPTIONS_CONFIG = {
+	...JSON_OPTION_CONFIG,
+	path: {
+		flag: "--path <dir>",
+		description: "Path to project root (directory containing keystroke.config.ts); auto-discovered from CWD if omitted"
+	}
+};
+function createWorkflowsCommand() {
+	const cmd = createTypedCommand({
+		name: "workflows",
+		description: "Manage, run, inspect, and debug workflows",
+		schema: WorkflowsOptionsSchema,
+		optionsConfig: WORKFLOWS_OPTIONS_CONFIG,
+		loadHandler: async () => (await import("./list.handler-BTWvCyjA.mjs")).handleWorkflowsList,
+		subcommands: [
+			createTypedCommand({
+				name: "list",
+				description: "List all workflows in the project",
+				schema: WorkflowsOptionsSchema,
+				optionsConfig: WORKFLOWS_OPTIONS_CONFIG,
+				loadHandler: async () => (await import("./list.handler-BTWvCyjA.mjs")).handleWorkflowsList
+			}),
+			createWorkflowsBuildCommand(),
+			createWorkflowsTryDeployCommand(),
+			createWorkflowsInspectCommand(),
+			createWorkflowsValidateCommand(),
+			createWorkflowsDiffCommand(),
+			createWorkflowsEnvCommand(),
+			createWorkflowsLogsCommand(),
+			createWorkflowsPausedCommand()
+		]
+	});
+	cmd.enablePositionalOptions();
+	cmd.passThroughOptions();
+	return cmd;
+}
+//#endregion
+export { createWorkflowsCommand };