@keystrokehq/cli 0.0.11 → 0.0.12

package/dist/{schedule-BWAI6qLx.mjs → task-BBgEvdG1.mjs}

@@ -1,6 +1,24 @@
 #!/usr/bin/env node
 
+import { n as __exportAll } from "./chunk-CH6r78ws.mjs";
+import { a as descriptionString, c as optionalDescriptionString, d as trimmedNonEmptyStringUnbounded, i as createStructuralSchema, n as credentialSetProxyConfigSchema, o as idNoSpacesString, s as jsonSchemaObject, t as CredentialSetManifestSchema, u as trimmedNonEmptyString } from "./schemas-DodkHgnS.mjs";
 import { z } from "zod";
+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());
+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 ../../node_modules/.pnpm/cron-schedule@6.0.0/node_modules/cron-schedule/dist/utils.js
 function extractDateElements(date) {
 	return {
@@ -391,28 +409,6 @@ function parseCronExpression(cronExpression) {
 	});
 }
 //#endregion
-//#region ../../packages/core/src/shared/duration.ts
-const MULTIPLIERS = {
-	s: 1e3,
-	m: 6e4,
-	h: 36e5,
-	d: 864e5,
-	w: 6048e5,
-	y: 31536e6
-};
-/**
-* Convert a {@link Duration} value into milliseconds.
-*
-* Accepts the full Duration union: a positive integer (treated as ms)
-* or a string like "5s", "2m", "1h", "1d", "1w", "1y".
-*/
-function parseDurationToMs(duration) {
-	if (typeof duration === "number") return duration;
-	const match = duration.match(/^(\d+)([smhdwy])$/);
-	if (!match?.[1] || !match[2]) throw new Error(`Invalid duration format: "${duration}". Expected a positive integer or a string like "5s", "2m", "1h", "1d", "1w", "1y".`);
-	return Number.parseInt(match[1], 10) * MULTIPLIERS[match[2]];
-}
-//#endregion
 //#region ../../packages/core/src/shared/schedule.ts
 /**
 * shared/schedule.ts
@@ -441,12 +437,12 @@ const CronExpressionSchema = z.string().superRefine((val, ctx) => {
 		});
 	}
 });
-const ScheduleSchema = z.union([
+z.union([
 	z.number().refine((val) => val > 0, { message: "Duration in milliseconds must be positive" }).refine(Number.isFinite, { message: "Duration in milliseconds must be finite" }).refine(Number.isInteger, { message: "Duration in milliseconds must be an integer" }),
 	DurationStringSchema,
 	CronExpressionSchema
 ]);
-const IANATimezoneSchema = z.enum([
+z.enum([
 	"UTC",
 	"GMT",
 	"Etc/UTC",
@@ -502,4 +498,378 @@ const IANATimezoneSchema = z.enum([
 	"Asia/Doha"
 ]);
 //#endregion
-export { parseDurationToMs as i, IANATimezoneSchema as n, ScheduleSchema as r, DurationSchema as t };
+//#region ../../packages/core/src/artifacts/source-analysis.ts
+const SourceLocationSchema = z.object({
+	filePath: z.string().min(1),
+	absoluteFilePath: z.string().min(1).optional(),
+	line: z.number().int().positive(),
+	column: z.number().int().positive(),
+	position: z.number().int().nonnegative().optional(),
+	endLine: z.number().int().positive(),
+	endColumn: z.number().int().positive(),
+	endPosition: z.number().int().nonnegative().optional(),
+	synthetic: z.boolean().optional()
+});
+z.string().min(1);
+const ImportSourceSchema = z.object({
+	kind: z.enum([
+		"local",
+		"module-import",
+		"namespace-import",
+		"dynamic"
+	]),
+	moduleSpecifier: z.string().min(1).optional(),
+	importName: z.string().min(1).optional(),
+	localName: z.string().min(1).optional(),
+	resolvedPath: z.string().min(1).optional()
+});
+const CallKindSchema = z.enum([
+	"workflow-step",
+	"agent",
+	"tool",
+	"hook",
+	"child-workflow",
+	"function-call",
+	"method-call",
+	"dynamic-call",
+	"parallel-call",
+	"process-exit",
+	"iife",
+	"expression"
+]);
+const CapturedVariableSourceKindSchema = z.enum([
+	"local-const",
+	"relative-import",
+	"package-import"
+]);
+const CapturedVariableValueTypeSchema = z.enum([
+	"string",
+	"number",
+	"boolean",
+	"object",
+	"array",
+	"function",
+	"unknown"
+]);
+z.object({
+	name: z.string().min(1),
+	value: z.union([
+		z.string(),
+		z.number(),
+		z.boolean()
+	]).optional(),
+	sourceText: z.string().optional(),
+	valueType: CapturedVariableValueTypeSchema,
+	resolvable: z.boolean(),
+	source: CapturedVariableSourceKindSchema,
+	importPath: z.string().optional(),
+	declaration: z.object({
+		filePath: z.string().min(1),
+		line: z.number().int().positive()
+	})
+});
+const IntegrationScopeSchema = z.enum([
+	"organization",
+	"project",
+	"user_provided_credential"
+]);
+const IntegrationCredentialRefSchema = z.discriminatedUnion("type", [z.object({
+	type: z.literal("id"),
+	id: z.string().startsWith("cset_")
+}), z.object({
+	type: z.literal("name"),
+	name: z.string().trim().min(1)
+})]);
+function hasProjectOrOrganizationScope(scope) {
+	return scope === "organization" || scope === "project";
+}
+const CredentialRefTokenKeyNameSchema = z.string().regex(/^[A-Za-z0-9_]+$/, "Credential key must contain only letters, digits, and underscores (required for ref-token proxying)");
+/** Shared enum for top-level credential-set `onCredentialRevoked` policy. */
+const OnCredentialRevokedSchema = z.enum(["fail", "retry-once"]);
+/** A credential set after resolution in a built manifest. Contains definition id, scope, alias, and credential keys.*/
+const ResolvedCredentialSetSchema = z.object({
+	resolvedId: z.string(),
+	scope: IntegrationScopeSchema.optional(),
+	alias: z.string().optional(),
+	credentialRef: IntegrationCredentialRefSchema.optional(),
+	/** Auth-shape keys expected post-resolve. */
+	credentialKeys: z.array(CredentialRefTokenKeyNameSchema),
+	/** Subset of `credentialKeys` that are optional in the auth shape. */
+	optionalCredentialKeys: z.array(CredentialRefTokenKeyNameSchema).optional(),
+	/** Auth-shaped vault keys required for vault reads and upload flows. */
+	storedCredentialKeys: z.array(CredentialRefTokenKeyNameSchema).optional(),
+	/** Subset of auth-shaped vault keys that may be absent from the vault without
+	* failing resolution. Derived from the credential set's `auth` schema. */
+	optionalStoredCredentialKeys: z.array(CredentialRefTokenKeyNameSchema).optional(),
+	proxy: credentialSetProxyConfigSchema.optional(),
+	/** When true, resolved values are passed raw (no ref-token proxy) for this set. */
+	needsRawSecret: z.boolean().optional(),
+	/** Policy when a step throws `CredentialRevokedError` against this credential set. */
+	onCredentialRevoked: OnCredentialRevokedSchema.optional(),
+	/** Persistence-layer schema fingerprint stamped at build time. The
+	* resolver's phase 2 compares this against the vault row's stored
+	* fingerprint and raises `CredentialSchemaMismatchError` on drift.
+	* Optional here so pre-fingerprint artifacts still parse; the
+	* workflow builder populates it for every authored credential set
+	* that has a resolvable fingerprint. */
+	schemaFingerprint: z.string().optional()
+}).superRefine((value, ctx) => {
+	if (value.credentialRef && !hasProjectOrOrganizationScope(value.scope)) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["credentialRef"],
+		message: "credentialRef requires scope to be \"project\" or \"organization\""
+	});
+});
+z.object({
+	credentialSetId: z.string(),
+	/** Auth-shape keys expected post-resolve. */
+	credentialKeys: z.array(CredentialRefTokenKeyNameSchema),
+	/** Optional subset of the auth-shape keys. */
+	optionalCredentialKeys: z.array(CredentialRefTokenKeyNameSchema).optional(),
+	/** Stored-shape keys required for vault reads. */
+	storedCredentialKeys: z.array(CredentialRefTokenKeyNameSchema).optional(),
+	/** Optional subset of the stored-shape keys. */
+	optionalStoredCredentialKeys: z.array(CredentialRefTokenKeyNameSchema).optional(),
+	schemaFingerprint: z.string().optional(),
+	/** Policy when a step throws `CredentialRevokedError` against this credential set. */
+	onCredentialRevoked: OnCredentialRevokedSchema.optional(),
+	proxy: credentialSetProxyConfigSchema.optional(),
+	needsRawSecret: z.boolean().optional(),
+	requiredOAuthScopes: z.array(z.string()).optional()
+});
+const CredentialRequirementEntrySchema = z.object({
+	credentialSetId: z.string(),
+	scope: IntegrationScopeSchema.optional(),
+	alias: z.string().optional(),
+	credentialRef: IntegrationCredentialRefSchema.optional(),
+	/** Auth-shape keys expected post-resolve. */
+	credentialKeys: z.array(CredentialRefTokenKeyNameSchema),
+	/** Optional subset of the auth-shape keys. */
+	optionalCredentialKeys: z.array(CredentialRefTokenKeyNameSchema).optional(),
+	/** Auth-shaped vault keys required for vault reads. */
+	storedCredentialKeys: z.array(CredentialRefTokenKeyNameSchema).optional(),
+	/** Optional subset of the stored-shape keys. */
+	optionalStoredCredentialKeys: z.array(CredentialRefTokenKeyNameSchema).optional(),
+	schemaFingerprint: z.string().optional(),
+	proxy: credentialSetProxyConfigSchema.optional(),
+	needsRawSecret: z.boolean().optional(),
+	/** Policy when a step throws `CredentialRevokedError` against this credential set. */
+	onCredentialRevoked: OnCredentialRevokedSchema.optional(),
+	requiredOAuthScopes: z.array(z.string()).optional()
+}).superRefine((value, ctx) => {
+	if (value.credentialRef && !hasProjectOrOrganizationScope(value.scope)) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["credentialRef"],
+		message: "credentialRef requires scope to be \"project\" or \"organization\""
+	});
+});
+z.object({
+	required: z.array(z.string()),
+	byStep: z.record(z.string(), z.array(CredentialRequirementEntrySchema))
+});
+const TriggerCallbackNameSchema = z.enum([
+	"filter",
+	"idempotencyKey",
+	"verify",
+	"callback"
+]);
+const TriggerCredentialRequirementEntrySchema = CredentialRequirementEntrySchema;
+const TriggerCredentialRequirementsSchema = z.object({
+	required: z.array(z.string()),
+	byCallback: z.partialRecord(TriggerCallbackNameSchema, z.array(TriggerCredentialRequirementEntrySchema))
+});
+const ExecutionIdentityPolicySchema = z.object({ subjectMode: z.enum(["never", "requiredWhenUserProvidedCredential"]) });
+z.object({
+	nodeId: z.string().min(1),
+	stepName: z.string().min(1),
+	label: z.string().min(1),
+	callKind: CallKindSchema,
+	stepId: z.string().min(1).optional(),
+	source: SourceLocationSchema.optional(),
+	astKind: z.string().min(1).optional(),
+	importSource: ImportSourceSchema.optional(),
+	outputBinding: z.string().min(1).optional(),
+	scopeOverride: IntegrationScopeSchema.optional(),
+	description: z.string().optional(),
+	sourceCode: z.string().optional(),
+	exportName: z.string().optional(),
+	inputSchema: JsonSchemaSchema.optional(),
+	outputSchema: JsonSchemaSchema.optional(),
+	credentialSets: z.array(ResolvedCredentialSetSchema).optional()
+});
+const TriggerTypeSchema = z.enum([
+	"webhook",
+	"cron",
+	"polling"
+]);
+/**
+* Persisted on `deployment_triggers.trigger_source`. Mirrors the
+* `webhookTrigger({ source: { type } })` discriminator so the server
+* can index-filter app-source rows during provider-webhook fanout.
+*/
+const TriggerSourceSchema = z.enum(["custom", "app"]);
+const WebhookMethodSchema = z.enum([
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH"
+]);
+const TriggerCallbackBundleUploadSchema = z.object({
+	code: z.string(),
+	hash: z.string(),
+	size: z.number()
+});
+const TriggerCallbackExportsSchema = z.object({
+	verify: z.string().min(1).optional(),
+	filter: z.string().min(1).optional(),
+	idempotencyKey: z.string().min(1).optional(),
+	callback: z.string().min(1).optional()
+});
+const TransformCallbackExportsSchema = z.object({ transform: z.string().min(1).optional() });
+z.object({
+	id: z.string(),
+	type: TriggerTypeSchema,
+	/**
+	* Source-of-truth discriminator for webhook triggers. `'custom'` means
+	* the trigger owns its own HTTP path; `'app'` means it is fanned out by
+	* a Keystroke-managed provider app. Undefined for non-webhook triggers.
+	*/
+	triggerSource: TriggerSourceSchema.optional(),
+	enabled: z.boolean(),
+	path: z.string().optional(),
+	method: WebhookMethodSchema.optional(),
+	schedule: z.string().optional(),
+	timezone: z.string().optional(),
+	config: z.record(z.string(), z.unknown()).optional(),
+	requiredCredentials: TriggerCredentialRequirementsSchema.optional(),
+	storagePath: z.string().min(1).optional(),
+	callbackBundle: TriggerCallbackBundleUploadSchema.optional(),
+	callbackExports: TriggerCallbackExportsSchema.optional(),
+	transformCallbackBundle: TriggerCallbackBundleUploadSchema.optional(),
+	transformCallbackExports: TransformCallbackExportsSchema.optional()
+});
+//#endregion
+//#region ../../packages/core/src/trigger/schemas.ts
+const credentialSetInstanceSchema = createStructuralSchema([
+	"id",
+	"auth",
+	"connections"
+], "a CredentialSet instance");
+const TriggerModeDefaultSchema = z.enum(["managed", "subscribable"]);
+const TriggerCallbackPresenceSchema = z.object({
+	filter: z.boolean(),
+	idempotencyKey: z.boolean(),
+	poll: z.boolean().optional(),
+	transformAllowed: z.boolean(),
+	verify: z.boolean().optional()
+});
+const TriggerRuntimeDescriptorSchema = z.object({ callbacks: TriggerCallbackPresenceSchema });
+const TriggerManifestSchema = z.object({
+	manifestVersion: z.literal(1),
+	type: z.literal("trigger"),
+	triggerType: TriggerTypeSchema,
+	name: trimmedNonEmptyString("Trigger name"),
+	description: descriptionString("Trigger description"),
+	enabled: z.boolean(),
+	modeDefault: TriggerModeDefaultSchema,
+	executionIdentityPolicy: ExecutionIdentityPolicySchema.optional(),
+	credentialSets: z.array(CredentialSetManifestSchema).optional(),
+	runtime: TriggerRuntimeDescriptorSchema
+});
+z.object({
+	credentialSets: z.array(credentialSetInstanceSchema).optional(),
+	description: descriptionString("Trigger description"),
+	enabled: z.boolean().default(true),
+	executionIdentityPolicy: ExecutionIdentityPolicySchema.optional(),
+	modeDefault: TriggerModeDefaultSchema.default("managed"),
+	name: trimmedNonEmptyString("Trigger name")
+});
+//#endregion
+//#region ../../packages/core/src/task/schemas.ts
+const agentInstanceSchema = createStructuralSchema([
+	"id",
+	"name",
+	"systemPrompt",
+	"model",
+	"input",
+	"output",
+	"workflowSafeReference"
+], "an Agent instance");
+const triggerInstanceSchema = createStructuralSchema([
+	"isTrigger",
+	"name",
+	"description",
+	"enabled"
+], "a trigger instance (use cronTrigger(), pollingTrigger(), or webhookTrigger())");
+const taskLifecycleSchema = z.object({
+	maxExecutions: z.number().int().positive().optional(),
+	expiresAt: z.union([z.date(), z.string().datetime()]).optional(),
+	expiresAfter: DurationSchema.optional()
+}).strict();
+z.object({
+	id: idNoSpacesString("Task ID"),
+	name: trimmedNonEmptyString("Task name"),
+	description: optionalDescriptionString("Task description"),
+	agent: agentInstanceSchema,
+	prompt: trimmedNonEmptyStringUnbounded("Task prompt"),
+	triggers: z.array(triggerInstanceSchema).min(1, { message: "At least one trigger is required" }),
+	lifecycle: taskLifecycleSchema.optional(),
+	tags: z.array(z.string()).optional()
+}).strict();
+const WorkflowSafeAgentReferenceSchema = z.object({
+	kind: z.literal("agent"),
+	authoredAgentId: z.string(),
+	displayName: z.string(),
+	runtimeKind: z.enum(["declarative", "runnable"]),
+	inputSchema: jsonSchemaObject.optional(),
+	outputSchema: jsonSchemaObject.optional(),
+	authoredExport: z.object({
+		exportName: z.string().optional(),
+		filePath: z.string().optional()
+	}).optional(),
+	metadata: jsonSchemaObject.optional()
+}).strict();
+const TaskBuildInfoStubSchema = z.object({
+	hash: SHA256HashSchema.optional(),
+	size: z.number().optional(),
+	metadata: jsonSchemaObject.optional()
+}).strict();
+/**
+* Extended trigger manifest schema for tasks.
+* Preserves runtime fields (schedule, timezone, path, method) that the base
+* TriggerManifestSchema strips. Tasks need these for trigger evaluation at runtime.
+*/
+const TaskTriggerManifestSchema = TriggerManifestSchema.extend({
+	runtime: TriggerRuntimeDescriptorSchema.extend({
+		schedule: z.string().optional(),
+		timezone: z.string().optional(),
+		path: z.string().optional(),
+		method: z.string().optional(),
+		input: z.unknown().optional(),
+		payloadMode: z.string().optional()
+	}),
+	/** Static payload for cron triggers */
+	payload: z.unknown().optional()
+});
+const TaskBuildManifestSchema = z.object({
+	manifestVersion: z.literal(1),
+	type: z.literal("task"),
+	id: z.string().min(1),
+	name: z.string().min(1),
+	description: z.string().optional(),
+	agentRef: WorkflowSafeAgentReferenceSchema,
+	prompt: z.string().min(1),
+	triggers: z.array(TaskTriggerManifestSchema),
+	lifecycle: z.object({
+		maxExecutions: z.number().int().positive().optional(),
+		expiresAt: z.string().optional(),
+		expiresAfter: z.string().optional()
+	}).strict().optional(),
+	tags: z.array(z.string()).optional(),
+	buildInfo: TaskBuildInfoStubSchema
+}).strict();
+//#endregion
+//#region ../../packages/core/src/task/index.ts
+var task_exports = /* @__PURE__ */ __exportAll({ TaskBuildManifestSchema: () => TaskBuildManifestSchema });
+//#endregion
+export { TaskBuildManifestSchema as n, task_exports as t };

package/dist/{task-target-build-D5IrHqSl.mjs → task-target-build-atWwwnSF.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { t as readCredentialKeysFromSchemaObject } from "./read-credential-keys-77a91T8M-B0eiobOd.mjs";
+import { t as readCredentialKeysFromSchemaObject } from "./read-credential-keys-77a91T8M-CzXPGxdU.mjs";
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
@@ -109,7 +109,7 @@ async function buildTaskTargetFile(options) {
 	return builtTasks;
 }
 async function bundleTaskTargetModule(options) {
-	const [{ rolldown }, { createEnvAccessPlugin, formatEnvAccessError }] = await Promise.all([import("rolldown"), import("./detect-env-access-CwkOYeYM-D4o8gRZs.mjs").then((n) => n.n).then((n) => n.n)]);
+	const [{ rolldown }, { createEnvAccessPlugin, formatEnvAccessError }] = await Promise.all([import("rolldown"), import("./detect-env-access-CwkOYeYM-EmkYvbfJ.mjs").then((n) => n.n).then((n) => n.n)]);
 	const entryId = "\0virtual:task-target-entry";
 	const trackedDependencies = /* @__PURE__ */ new Set();
 	const envViolations = [];
@@ -216,7 +216,7 @@ async function attachTaskTargetTriggers(options) {
 		options.artifact.triggers.push(...buildTaskTriggerArtifactsWithoutBundles(options.entry.taskMetadata.triggers, options.artifact.task.taskId, options.artifact.task.taskName));
 		return [];
 	}
-	const { buildTriggerArtifacts } = await import("./trigger-artifacts-B3OCTX9K-ME6IVdUB.mjs").then((n) => n.n);
+	const { buildTriggerArtifacts } = await import("./trigger-artifacts-RizI57RC-C-yCtEi-.mjs").then((n) => n.n);
 	const triggerResult = await buildTriggerArtifacts(options.entry.taskMetadata.triggers, options.artifact.task.taskId, options.artifact.task.taskName, options.projectRoot, {
 		workflowExportName: options.entry.source.localExportName,
 		workflowFilePath: options.entry.runtimeBundlePath
@@ -289,17 +289,17 @@ function buildTaskTriggerCredentialRequirements(credentialSets, callbacks) {
 	};
 	const entries = credentialSets.map((credentialSet) => {
 		const optionalCredentialKeys = readOptionalJsonSchemaKeysFromSchemaObject(credentialSet.auth);
-		const resolveCacheMs = "resolveCacheMs" in credentialSet && typeof credentialSet.resolveCacheMs === "number" ? credentialSet.resolveCacheMs : void 0;
+		const dynamicResolutionCacheMs = "dynamicResolutionCacheMs" in credentialSet && typeof credentialSet.dynamicResolutionCacheMs === "number" ? credentialSet.dynamicResolutionCacheMs : void 0;
 		const topLevelRevoked = "onCredentialRevoked" in credentialSet ? credentialSet.onCredentialRevoked : void 0;
 		return {
-			credentialSetId: credentialSet.resolvedCredentialSetId,
+			credentialSetId: credentialSet.id,
 			credentialKeys: readCredentialKeysFromSchemaObject(credentialSet.auth),
 			...optionalCredentialKeys.length > 0 ? { optionalCredentialKeys } : {},
-			...typeof resolveCacheMs === "number" && resolveCacheMs > 0 ? { resolveCacheMs } : {},
+			...typeof dynamicResolutionCacheMs === "number" && dynamicResolutionCacheMs > 0 ? { dynamicResolutionCacheMs } : {},
 			...topLevelRevoked ? { onCredentialRevoked: topLevelRevoked } : {}
 		};
 	});
-	const requiredIds = credentialSets.map((credentialSet) => credentialSet.resolvedCredentialSetId);
+	const requiredIds = credentialSets.map((credentialSet) => credentialSet.id);
 	const byCallback = {};
 	if (callbacks?.poll) byCallback.callback = entries;
 	if (callbacks?.verify) byCallback.verify = entries;
@@ -319,7 +319,7 @@ function createPreparedTaskTarget(artifact, triggers) {
 	};
 }
 async function tryParseTaskBuildManifest(manifest) {
-	const { TaskBuildManifestSchema } = await import("./task-1qz1XNq7.mjs").then((n) => n.t);
+	const { TaskBuildManifestSchema } = await import("./task-BBgEvdG1.mjs").then((n) => n.t);
 	const result = TaskBuildManifestSchema.safeParse(manifest);
 	return result.success ? result.data : null;
 }

package/dist/task-target-deploy-CRsrQTOy.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+import { n as deployTaskTargets } from "./task-target-deploy-CZBGNC0H-BwPSfaJQ.mjs";
+export { deployTaskTargets };

package/dist/{task-target-deploy-Bf5i3ox1-2K0hAwzk.mjs → task-target-deploy-CZBGNC0H-BwPSfaJQ.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { r as SHA256HashSchema } from "./common-B3bLe3Mk.mjs";
+import { n as SHA256HashSchema } from "./common-BaGFkj3n.mjs";
 import { createHash } from "node:crypto";
 //#region ../../packages/shared-types/src/deployments/api/snapshot-payload.ts
 function sortObjectKeysDeep(value) {
@@ -100,7 +100,7 @@ function buildCanonicalProjectSnapshotPayload(params) {
 	};
 }
 //#endregion
-//#region ../../packages/workflow-deploy/dist/task-target-deploy-Bf5i3ox1.mjs
+//#region ../../packages/workflow-deploy/dist/task-target-deploy-CZBGNC0H.mjs
 function computeProjectSnapshotHash(params) {
 	const hex = createHash("sha256").update(JSON.stringify(buildCanonicalProjectSnapshotPayload({
 		workflows: params.workflows,

package/dist/task-target-deploy-runner.mjs

@@ -2,7 +2,7 @@
 
 import "./default-urls-BS4twrsS.mjs";
 import { l as resolveAuthOptions } from "./dist-BF6r1hfv.mjs";
-import { n as findProjectRoot, t as assertWorkflowProjectRoot } from "./project-config-D9eFU8Jk.mjs";
+import { n as findProjectRoot, t as assertWorkflowProjectRoot } from "./project-config-CJGSh2RQ.mjs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
@@ -116,7 +116,7 @@ function restartStage(options, projectRoot, stage) {
 }
 async function runBuildPhase(options, projectRoot) {
 	const projectConfig = await assertWorkflowProjectRoot(projectRoot);
-	const { buildTaskTargetEntries } = await import("./task-target-build-D5IrHqSl.mjs");
+	const { buildTaskTargetEntries } = await import("./task-target-build-atWwwnSF.mjs");
 	await writeBuildDescriptor(projectRoot, {
 		projectRoot,
 		projectConfig,
@@ -129,7 +129,7 @@ async function runBuildPhase(options, projectRoot) {
 }
 async function runPreparePhase(projectRoot) {
 	const buildDescriptor = await readBuildDescriptor(projectRoot);
-	const { prepareTaskTargetBuiltTasks } = await import("./task-target-build-D5IrHqSl.mjs");
+	const { prepareTaskTargetBuiltTasks } = await import("./task-target-build-atWwwnSF.mjs");
 	const prepareResult = await prepareTaskTargetBuiltTasks({
 		builtTasks: buildDescriptor.builtTasks,
 		projectRoot
@@ -158,11 +158,11 @@ async function resolveDeployAuthOptions(options) {
 }
 async function runDeployPhase(options, projectRoot) {
 	const descriptor = await readDescriptor(projectRoot);
-	const { createDeployClient } = await import("./deploy-B8TYutOi.mjs");
+	const { createDeployClient } = await import("./deploy-BvaFgVvf.mjs");
 	const client = createDeployClient(await resolveDeployAuthOptions(options));
 	const auth = await client.public.auth.validate();
 	if (auth.organizationId !== descriptor.projectConfig.organizationId) throw new Error(`Project organization mismatch: config=${descriptor.projectConfig.organizationId} auth=${auth.organizationId}`);
-	const { deployTaskTargets } = await import("./task-target-deploy-Bzfftyru.mjs");
+	const { deployTaskTargets } = await import("./task-target-deploy-CRsrQTOy.mjs");
 	const result = await deployTaskTargets({
 		preparedTasks: descriptor.preparedTasks,
 		client,