@keystrokehq/cli 0.0.18 → 0.0.20

package/dist/src-BHTjsZ9V.mjs

@@ -0,0 +1,456 @@
+#!/usr/bin/env node
+
+import { n as __exportAll, r as __reExport } from "./chunk-DYxdGL9S.mjs";
+import { a as CapturedVariableValueTypeSchema, i as CapturedVariableSourceKindSchema, n as CallsiteFingerprintSchema, o as ImportSourceSchema, r as CapturedVariableSchema, s as SourceLocationSchema, t as CallKindSchema } from "./source-analysis-BMMPIHN9.mjs";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+const SHA256HashSchema = z.string().length(64, "Must be 64 characters").regex(/^[a-f0-9]{64}$/i, "Must be hexadecimal").transform((value) => value);
+const JsonSchemaSchema = z.record(z.string(), z.unknown());
+const RetryConfigSchema = z.object({
+	constant: z.object({
+		attempts: z.number().int().min(1).max(10),
+		seconds: z.number().positive()
+	}).optional(),
+	exponential: z.object({
+		attempts: z.number().int().min(1).max(10),
+		base: z.number().min(1).optional(),
+		multiplier: z.number().positive().optional()
+	}).optional()
+}).refine((data) => {
+	return data.constant !== void 0 !== (data.exponential !== void 0);
+}, { error: "Retry config must specify exactly one of constant or exponential strategy" });
+//#endregion
+//#region ../../packages/workflow-build-contracts/src/credential-requirements.ts
+var credential_requirements_exports = /* @__PURE__ */ __exportAll({});
+import * as import__keystrokehq_core_artifacts from "@keystrokehq/core/artifacts";
+__reExport(credential_requirements_exports, import__keystrokehq_core_artifacts);
+//#endregion
+//#region ../../packages/workflow-build-contracts/src/schema-fingerprint.ts
+/**
+* schema-fingerprint.ts
+*
+* Computes a deterministic fingerprint (hash) of a credential set's schema.
+* Used as a persistence-layer identity stamp: the workflow-builder stamps each
+* credential requirement with its fingerprint at build time, the server stamps
+* each vault row with the fingerprint at upload time, and the executor's
+* credential resolver compares the two at read time so schema drift surfaces
+* as a `CredentialSchemaMismatchError` rather than a silent decode into a
+* stale shape.
+*
+* The fingerprint is deterministic: identical JSON schemas always produce the
+* same hash regardless of property ordering, timestamps, or other
+* non-structural differences.
+*
+* @remarks
+* This is the *persistence* fingerprint. The construction-time registry in
+* `credential-set/registry.ts` uses a different (Zod-structural) fingerprint
+* purely for in-process identity collision detection; the two fingerprints
+* serve different purposes and do not need to match.
+*/
+/**
+* Compute a deterministic fingerprint for a JSON schema object.
+*
+* The schema is the output of `schemaToJsonSchema(zodSchema)` — a plain JSON
+* object describing the shape of the Zod schema.
+*
+* Properties are sorted recursively before hashing to ensure deterministic
+* output regardless of insertion order.
+*
+* @example
+* ```ts
+* const auth = schemaToJsonSchema(credentialSet.auth);
+* const stored = credentialSet.stored ? schemaToJsonSchema(credentialSet.stored) : undefined;
+* const fingerprint = computeSchemaFingerprint(auth, stored);
+* ```
+*
+* @see CredentialSchemaMismatchError
+*/
+function computeSchemaFingerprint(authSchema, storedSchema) {
+	const normalized = sortDeep({
+		auth: authSchema,
+		...storedSchema ? { stored: storedSchema } : {}
+	});
+	const json = JSON.stringify(normalized);
+	return createHash("sha256").update(json).digest("hex").substring(0, 16);
+}
+function sortDeep(value) {
+	if (value === null || value === void 0) return value;
+	if (Array.isArray(value)) return value.map(sortDeep);
+	if (typeof value === "object") {
+		const sorted = {};
+		for (const key of Object.keys(value).sort()) sorted[key] = sortDeep(value[key]);
+		return sorted;
+	}
+	return value;
+}
+//#endregion
+//#region ../../packages/workflow-build-contracts/src/declared-credential-requirements.ts
+function schemaToJsonSchema(schema) {
+	return JsonSchemaSchema.parse({ ...z.toJSONSchema(schema, { unrepresentable: "any" }) });
+}
+function readSchemaKeys(schema, propertyKey) {
+	if (schema === null || typeof schema !== "object") return [];
+	const candidate = schema[propertyKey];
+	if (candidate === null || typeof candidate !== "object" || Array.isArray(candidate)) return [];
+	return Object.keys(candidate).sort();
+}
+/**
+* Returns sorted keys whose Zod schema field is wrapped in `z.optional()` or `z.default()`.
+* Both mean the vault can omit the key at runtime.
+*/
+function readOptionalSchemaKeys(schema) {
+	if (schema === null || typeof schema !== "object") return [];
+	const shape = schema.shape;
+	if (shape === null || typeof shape !== "object" || Array.isArray(shape)) return [];
+	return Object.entries(shape).filter(([, field]) => field instanceof z.ZodOptional || field instanceof z.ZodDefault).map(([key]) => key).sort();
+}
+/**
+* Returns sorted keys that are NOT listed in the JSON Schema `required` array.
+*/
+function readOptionalJsonSchemaKeys(schema) {
+	if (schema === null || typeof schema !== "object") return [];
+	const record = schema;
+	const properties = record.properties;
+	if (properties === null || typeof properties !== "object" || Array.isArray(properties)) return [];
+	const requiredSet = new Set(Array.isArray(record.required) ? record.required : []);
+	return Object.keys(properties).filter((key) => !requiredSet.has(key)).sort();
+}
+function toDeclaredCredentialRequirement(credentialSet) {
+	const optionalAuthKeys = credentialSet.optionalCredentialKeys;
+	const optionalStoredKeys = credentialSet.optionalStoredCredentialKeys;
+	const schemaFingerprint = computeSchemaFingerprint(schemaToJsonSchema(credentialSet.auth));
+	const onCredentialRevoked = credentialSet.onCredentialRevoked;
+	return {
+		credentialSetId: credentialSet.id,
+		credentialKeys: [...credentialSet.credentialKeys],
+		...optionalAuthKeys.length > 0 ? { optionalCredentialKeys: [...optionalAuthKeys] } : {},
+		storedCredentialKeys: [...credentialSet.storedCredentialKeys],
+		...optionalStoredKeys.length > 0 ? { optionalStoredCredentialKeys: [...optionalStoredKeys] } : {},
+		schemaFingerprint,
+		...onCredentialRevoked ? { onCredentialRevoked } : {},
+		...credentialSet.proxy ? { proxy: credentialSet.proxy } : {},
+		...credentialSet.needsRawSecret === true ? { needsRawSecret: true } : {}
+	};
+}
+function toDeclaredCredentialRequirements(credentialSets) {
+	return credentialSets.map(toDeclaredCredentialRequirement);
+}
+function manifestToDeclaredCredentialRequirement(credentialSet) {
+	const authKeys = readSchemaKeys(credentialSet.auth, "properties");
+	const optionalAuthKeys = readOptionalJsonSchemaKeys(credentialSet.auth);
+	const storedSchema = credentialSet.auth;
+	const storedKeys = readSchemaKeys(storedSchema, "properties");
+	const optionalStoredKeys = readOptionalJsonSchemaKeys(storedSchema);
+	const schemaFingerprint = credentialSet.auth ? computeSchemaFingerprint(credentialSet.auth) : void 0;
+	const onCredentialRevoked = credentialSet.onCredentialRevoked;
+	return {
+		credentialSetId: credentialSet.id,
+		credentialKeys: authKeys,
+		...optionalAuthKeys.length > 0 ? { optionalCredentialKeys: optionalAuthKeys } : {},
+		storedCredentialKeys: storedKeys,
+		...optionalStoredKeys.length > 0 ? { optionalStoredCredentialKeys: optionalStoredKeys } : {},
+		...schemaFingerprint ? { schemaFingerprint } : {},
+		...onCredentialRevoked ? { onCredentialRevoked } : {},
+		...credentialSet.proxy ? { proxy: credentialSet.proxy } : {},
+		...credentialSet.needsRawSecret === true ? { needsRawSecret: true } : {}
+	};
+}
+function manifestsToDeclaredCredentialRequirements(credentialSets) {
+	return credentialSets.map(manifestToDeclaredCredentialRequirement);
+}
+//#endregion
+//#region ../../packages/workflow-build-contracts/src/flow-graph-schema.ts
+const DecisionKindSchema = z.enum([
+	"if",
+	"switch",
+	"ternary"
+]);
+const ParallelKindSchema = z.enum([
+	"all",
+	"race",
+	"allSettled",
+	"any"
+]);
+const LoopKindSchema = z.enum([
+	"for",
+	"for-of",
+	"for-in",
+	"while",
+	"do-while"
+]);
+const ExitKindSchema = z.enum(["return", "throw"]);
+const FlowBranchKindSchema = z.enum([
+	"then",
+	"else",
+	"parallel-branch"
+]);
+const FlowNodeTypeSchema = z.enum([
+	"entry",
+	"step",
+	"code-block",
+	"decision",
+	"merge",
+	"fork",
+	"join",
+	"parallel-map",
+	"loop",
+	"exit"
+]);
+const FlowEdgeTypeSchema = z.enum([
+	"default",
+	"true-branch",
+	"false-branch",
+	"merge",
+	"loop-entry",
+	"loop-back",
+	"parallel",
+	"return"
+]);
+const FlowStatementSchema = z.object({
+	kind: z.string().min(1),
+	label: z.string().min(1),
+	sourceText: z.string().min(1)
+});
+const EntryNodeDataSchema = z.object({ kind: z.literal("entry") });
+const StepNodeDataSchema = z.object({
+	kind: z.literal("call"),
+	callKind: CallKindSchema,
+	stepName: z.string().min(1),
+	callsiteFingerprint: CallsiteFingerprintSchema.optional(),
+	exportName: z.string().min(1).optional(),
+	stepId: z.string().min(1).optional(),
+	awaited: z.boolean().optional(),
+	dynamic: z.boolean().optional(),
+	recursive: z.boolean().optional(),
+	importSource: ImportSourceSchema.optional(),
+	outputBinding: z.string().min(1).optional(),
+	description: z.string().optional(),
+	inputSchema: JsonSchemaSchema.optional(),
+	outputSchema: JsonSchemaSchema.optional(),
+	source: SourceLocationSchema.optional(),
+	astKind: z.string().min(1).optional(),
+	scopeOverride: credential_requirements_exports.IntegrationScopeSchema.optional(),
+	credentialSets: z.array(credential_requirements_exports.ResolvedCredentialSetSchema).optional(),
+	requiredOAuthScopes: z.array(z.string()).optional()
+});
+const CodeBlockNodeDataSchema = z.object({
+	kind: z.literal("code-block"),
+	statements: z.array(FlowStatementSchema)
+});
+const DecisionNodeDataSchema = z.object({
+	kind: z.literal("decision"),
+	decisionKind: DecisionKindSchema.optional(),
+	source: SourceLocationSchema.optional(),
+	astKind: z.string().min(1).optional(),
+	conditionText: z.string().optional()
+});
+const MergeNodeDataSchema = z.object({
+	kind: z.literal("merge"),
+	source: SourceLocationSchema.optional()
+});
+const ForkNodeDataSchema = z.object({
+	kind: z.literal("fork"),
+	parallelKind: ParallelKindSchema.optional(),
+	preStatements: z.array(FlowStatementSchema).optional(),
+	source: SourceLocationSchema.optional(),
+	astKind: z.string().min(1).optional()
+});
+const JoinNodeDataSchema = z.object({
+	kind: z.literal("join"),
+	outputBinding: z.string().min(1).optional(),
+	source: SourceLocationSchema.optional()
+});
+const ParallelMapNodeDataSchema = z.object({
+	kind: z.literal("parallel-map"),
+	parallelKind: ParallelKindSchema.optional(),
+	iterationExpression: z.string().optional(),
+	stepNames: z.array(z.string()).optional(),
+	outputBinding: z.string().min(1).optional(),
+	preStatements: z.array(FlowStatementSchema).optional(),
+	source: SourceLocationSchema.optional(),
+	astKind: z.string().min(1).optional()
+});
+const LoopNodeDataSchema = z.object({
+	kind: z.literal("loop"),
+	loopKind: LoopKindSchema.optional(),
+	source: SourceLocationSchema.optional(),
+	astKind: z.string().min(1).optional(),
+	conditionText: z.string().optional()
+});
+const ExitNodeDataSchema = z.object({
+	kind: z.literal("exit"),
+	exitKind: ExitKindSchema,
+	sourceText: z.string().optional(),
+	source: SourceLocationSchema.optional(),
+	astKind: z.string().min(1).optional()
+});
+const FlowNodeDataSchema = z.discriminatedUnion("kind", [
+	EntryNodeDataSchema,
+	StepNodeDataSchema,
+	CodeBlockNodeDataSchema,
+	DecisionNodeDataSchema,
+	MergeNodeDataSchema,
+	ForkNodeDataSchema,
+	JoinNodeDataSchema,
+	ParallelMapNodeDataSchema,
+	LoopNodeDataSchema,
+	ExitNodeDataSchema
+]);
+const FlowEdgeDataSchema = z.object({ branchKind: FlowBranchKindSchema.optional() }).catchall(z.unknown());
+const FlowPositionSchema = z.object({
+	x: z.number().finite(),
+	y: z.number().finite()
+});
+const FlowNodeSchema = z.object({
+	id: z.string().min(1),
+	type: FlowNodeTypeSchema,
+	label: z.string(),
+	position: FlowPositionSchema,
+	data: FlowNodeDataSchema
+});
+const FlowEdgeSchema = z.object({
+	id: z.string().min(1),
+	source: z.string().min(1),
+	target: z.string().min(1),
+	type: FlowEdgeTypeSchema,
+	label: z.string().optional(),
+	data: FlowEdgeDataSchema.optional()
+});
+const FlowGraphSchema = z.object({
+	nodes: z.array(FlowNodeSchema),
+	edges: z.array(FlowEdgeSchema),
+	entryPoint: z.string().min(1),
+	exitPoints: z.array(z.string().min(1)),
+	generatedAt: z.iso.datetime(),
+	diagnostics: z.array(z.string())
+});
+//#endregion
+//#region ../../packages/workflow-build-contracts/src/workflow-build-manifest.ts
+const WORKFLOW_MANIFEST_GENERATOR = "local-build";
+const WORKFLOW_MANIFEST_SCHEMA_VERSION = "1.0.0";
+const WORKFLOW_MANIFEST_GENERATOR_VERSION = "1.1.0";
+const WorkflowIdentitySchema = z.object({
+	name: z.string().trim().min(1).max(255),
+	description: z.string().trim().min(1).optional(),
+	tags: z.array(z.string()).optional()
+});
+const StepIdentitySchema = z.object({
+	name: z.string().trim().min(1).max(255),
+	description: z.string().trim().min(1).optional(),
+	tags: z.array(z.string()).optional()
+});
+const WorkflowIOSchema = z.object({
+	input: JsonSchemaSchema.nullable(),
+	output: JsonSchemaSchema.nullable()
+});
+const BuildInfoSchema = z.object({
+	timestamp: z.iso.datetime(),
+	builderVersion: z.string().min(1),
+	generatedBy: z.literal(WORKFLOW_MANIFEST_GENERATOR),
+	gitCommit: z.string().optional(),
+	gitBranch: z.string().optional(),
+	gitIsDirty: z.boolean().optional(),
+	nodeVersion: z.string().min(1),
+	platform: z.string().min(1),
+	sourceChecksumAlgorithm: z.enum(["sha256"]),
+	sourceChecksum: z.string().length(64),
+	generatedFiles: z.array(z.string().min(1))
+});
+const ManifestDependenciesSchema = z.object({
+	localFiles: z.record(z.string(), z.string()),
+	packages: z.record(z.string(), z.string()),
+	workspacePackages: z.record(z.string(), z.string()),
+	builtins: z.array(z.string())
+});
+const DurationSchema = z.union([z.number().int().positive().finite(), z.string().regex(/^[1-9]\d*[smhdwy]$/)]);
+const WorkflowTriggerBindingSchema = z.object({
+	/** Authored trigger name (from `xxxTrigger({ name: ... })`). */
+	authoredTriggerId: z.string().min(1),
+	triggerType: z.enum([
+		"webhook",
+		"cron",
+		"polling"
+	]),
+	hasTransform: z.boolean(),
+	narrowedFrom: z.string().optional(),
+	lineage: z.array(z.string()).optional()
+});
+const WorkflowCoreManifestSchema = z.object({
+	schemaVersion: z.literal(WORKFLOW_MANIFEST_SCHEMA_VERSION),
+	id: z.string().min(1),
+	name: z.string().trim().min(1).max(255),
+	description: z.string().trim().min(1).optional(),
+	tags: z.array(z.string()).optional(),
+	exportName: z.string().min(1),
+	workflowSchemas: WorkflowIOSchema,
+	workflowGlobals: JsonSchemaSchema.optional(),
+	timeout: DurationSchema.optional(),
+	triggers: z.array(WorkflowTriggerBindingSchema).optional()
+});
+const WorkflowBuildManifestSchema = WorkflowCoreManifestSchema.extend({
+	workflowSource: SourceLocationSchema.optional(),
+	buildInfo: BuildInfoSchema,
+	dependencies: ManifestDependenciesSchema,
+	hasCycles: z.boolean().optional(),
+	credentials: credential_requirements_exports.CredentialRequirementsSchema.optional(),
+	sandboxes: z.array(z.record(z.string(), z.unknown())).optional(),
+	steps: z.record(z.string(), credential_requirements_exports.WorkflowStepEntrySchema)
+});
+const UploadBundleOptionsSchema = z.object({
+	organizationId: z.string(),
+	workflowId: z.string(),
+	bundle: z.instanceof(Uint8Array).optional(),
+	manifest: WorkflowBuildManifestSchema,
+	sourcePath: z.string().optional(),
+	triggers: z.array(credential_requirements_exports.TriggerUploadDataSchema).optional(),
+	bundleSize: z.number().optional(),
+	bundleHash: SHA256HashSchema.optional(),
+	skipVersionBump: z.boolean().optional(),
+	projectRoot: z.string().optional(),
+	projectId: z.uuid(),
+	flowJson: FlowGraphSchema.optional(),
+	deploymentSnapshotOnly: z.boolean().optional()
+});
+//#endregion
+//#region ../../packages/workflow-build-contracts/src/index.ts
+var src_exports = /* @__PURE__ */ __exportAll({
+	BuildInfoSchema: () => BuildInfoSchema,
+	CallKindSchema: () => CallKindSchema,
+	CallsiteFingerprintSchema: () => CallsiteFingerprintSchema,
+	CapturedVariableSchema: () => CapturedVariableSchema,
+	CapturedVariableSourceKindSchema: () => CapturedVariableSourceKindSchema,
+	CapturedVariableValueTypeSchema: () => CapturedVariableValueTypeSchema,
+	FlowBranchKindSchema: () => FlowBranchKindSchema,
+	FlowEdgeDataSchema: () => FlowEdgeDataSchema,
+	FlowEdgeSchema: () => FlowEdgeSchema,
+	FlowEdgeTypeSchema: () => FlowEdgeTypeSchema,
+	FlowGraphSchema: () => FlowGraphSchema,
+	FlowNodeDataSchema: () => FlowNodeDataSchema,
+	FlowNodeSchema: () => FlowNodeSchema,
+	FlowNodeTypeSchema: () => FlowNodeTypeSchema,
+	ImportSourceSchema: () => ImportSourceSchema,
+	JsonSchemaSchema: () => JsonSchemaSchema,
+	ManifestDependenciesSchema: () => ManifestDependenciesSchema,
+	RetryConfigSchema: () => RetryConfigSchema,
+	SHA256HashSchema: () => SHA256HashSchema,
+	SourceLocationSchema: () => SourceLocationSchema,
+	StepIdentitySchema: () => StepIdentitySchema,
+	UploadBundleOptionsSchema: () => UploadBundleOptionsSchema,
+	WORKFLOW_MANIFEST_GENERATOR: () => WORKFLOW_MANIFEST_GENERATOR,
+	WORKFLOW_MANIFEST_GENERATOR_VERSION: () => WORKFLOW_MANIFEST_GENERATOR_VERSION,
+	WORKFLOW_MANIFEST_SCHEMA_VERSION: () => WORKFLOW_MANIFEST_SCHEMA_VERSION,
+	WorkflowBuildManifestSchema: () => WorkflowBuildManifestSchema,
+	WorkflowCoreManifestSchema: () => WorkflowCoreManifestSchema,
+	WorkflowIOSchema: () => WorkflowIOSchema,
+	WorkflowIdentitySchema: () => WorkflowIdentitySchema,
+	computeSchemaFingerprint: () => computeSchemaFingerprint,
+	manifestToDeclaredCredentialRequirement: () => manifestToDeclaredCredentialRequirement,
+	manifestsToDeclaredCredentialRequirements: () => manifestsToDeclaredCredentialRequirements,
+	readOptionalJsonSchemaKeys: () => readOptionalJsonSchemaKeys,
+	readOptionalSchemaKeys: () => readOptionalSchemaKeys,
+	toDeclaredCredentialRequirement: () => toDeclaredCredentialRequirement,
+	toDeclaredCredentialRequirements: () => toDeclaredCredentialRequirements
+});
+__reExport(src_exports, credential_requirements_exports);
+//#endregion
+export { WorkflowCoreManifestSchema as a, readOptionalJsonSchemaKeys as c, WorkflowBuildManifestSchema as i, JsonSchemaSchema as l, WORKFLOW_MANIFEST_GENERATOR as n, FlowGraphSchema as o, WORKFLOW_MANIFEST_SCHEMA_VERSION as r, manifestToDeclaredCredentialRequirement as s, src_exports as t, SHA256HashSchema as u };

package/dist/{src-B0tNjKMg.mjs → src-BYQwp8Ig.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { a as createKyInstance, i as buildSearchParams, n as auth, r as bundles, s as getClientEnv, t as projects$1 } from "./projects-fWvIJQ80.mjs";
+import { a as createKyInstance, i as buildSearchParams, n as auth, r as bundles, s as getClientEnv, t as projects$1 } from "./projects-s5ehKLil.mjs";
 //#region ../../packages/workflow-sdk/src/v1/admin.ts
 const admin = (api) => ({
 	orgs: {

package/dist/{switch.handler-Cu81T2HY.mjs → switch.handler-CV4ZBXAu.mjs}

@@ -2,7 +2,7 @@
 
 import { a as ui, j as throwReportedCliExit } from "./keystroke.mjs";
 import { n as credentials } from "./dist-CIInPRGh.mjs";
-import { i as requireClient } from "./context-Bid-Rqj7.mjs";
+import { i as requireClient } from "./context-BUzxM3QI.mjs";
 import { select } from "@clack/prompts";
 //#region src/commands/org/switch.handler.ts
 async function handleOrgSwitch(_options, ctx) {

package/dist/{sync-CXNveL61.mjs → sync-KCVM02IY.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { t as createTypedCommand } from "./commander-BE37hxR3.mjs";
+import { t as createTypedCommand } from "./commander-DQLrBSIW.mjs";
 import { z } from "zod";
 //#region src/commands/sync/sync.command.ts
 /**
@@ -32,7 +32,7 @@ function createSyncCommand() {
 		description: "Sync local workflows with Keystroke",
 		schema: SyncOptionsSchema,
 		optionsConfig: SYNC_OPTIONS_CONFIG,
-		loadHandler: async () => (await import("./sync.handler-7g1yDt0H.mjs")).handleSync
+		loadHandler: async () => (await import("./sync.handler-Cuw89341.mjs")).handleSync
 	});
 }
 //#endregion

package/dist/{sync.handler-7g1yDt0H.mjs → sync.handler-Cuw89341.mjs}

@@ -2,12 +2,12 @@
 
 import { P as logger, a as ui, j as throwReportedCliExit, l as isLocalMode, y as toErrorMessage } from "./keystroke.mjs";
 import { i as projects } from "./dist-CIInPRGh.mjs";
-import { a as validateApiKey, i as requireClient } from "./context-Bid-Rqj7.mjs";
-import { n as deployFromDir } from "./dist-WFPTDQB3.mjs";
-import { t as requireWorkflowsDir } from "./resolve-project-CNQtOWE4.mjs";
-import { a as runWorkflowBuild, n as renderBuildFailure, r as renderBuildHeader } from "./workflow-build-_WNsLKwW.mjs";
-import { t as createBuildProgress } from "./build-progress-AR8xow4_.mjs";
-import { t as createDeployProgress } from "./deploy-progress-DK87VKJ-.mjs";
+import { a as validateApiKey, i as requireClient } from "./context-BUzxM3QI.mjs";
+import { n as deployFromDir } from "./dist-BGrWr5fp.mjs";
+import { t as requireWorkflowsDir } from "./resolve-project-CWP2fji3.mjs";
+import { a as runWorkflowBuild, n as renderBuildFailure, r as renderBuildHeader } from "./workflow-build-IGYhEC8Y.mjs";
+import { t as createBuildProgress } from "./build-progress-BVwDg6lC.mjs";
+import { t as createDeployProgress } from "./deploy-progress-CyolzjRB.mjs";
 //#region src/commands/sync/sync.handler.ts
 async function handleSync(options, ctx) {
 	try {