@keystrokehq/cli 0.0.18 → 0.0.20

package/dist/task-BguWXIiH.mjs

@@ -1,486 +0,0 @@
-#!/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-B8c7Z5Iy.mjs";
-import { t as parseCronExpression } from "./cron-parser-Dw_cWzFu.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 ../../packages/core/src/shared/schedule.ts
-/**
-* shared/schedule.ts
-*
-* Unified schedule type that supports both simple intervals and cron expressions.
-* Can be used in both cron and polling triggers for maximum flexibility.
-*
-* Template literal types provide compile-time type safety.
-* Zod schemas with refinements provide runtime validation.
-*/
-const DurationSchema = z.union([z.number().int().positive().finite(), z.string().regex(/^[1-9]\d*[smhdwy]$/)]);
-const DurationStringSchema = z.string().refine((val) => /^\d+[smhdwy]$/.test(val), { message: "Invalid duration format. Must be a positive integer followed by s, m, h, d, w, or y (e.g., \"5m\", \"1h\")" }).refine((val) => {
-	const match = val.match(/^(\d+)[smhdwy]$/);
-	if (!match?.[1]) return false;
-	const num = Number.parseInt(match[1], 10);
-	return num > 0 && Number.isFinite(num);
-}, { message: "Duration value must be a positive integer greater than 0" });
-const CronExpressionSchema = z.string().superRefine((val, ctx) => {
-	try {
-		parseCronExpression(val);
-	} catch (error) {
-		const errorMessage = error instanceof Error ? error.message : "Invalid cron expression format";
-		ctx.addIssue({
-			code: "custom",
-			message: `Invalid cron expression: ${errorMessage}. Must be a valid 5-field cron: minute hour day month weekday (e.g., "0 9 * * *", "*/15 * * * *")`
-		});
-	}
-});
-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
-]);
-z.enum([
-	"UTC",
-	"GMT",
-	"Etc/UTC",
-	"Etc/GMT",
-	"America/New_York",
-	"America/Chicago",
-	"America/Denver",
-	"America/Los_Angeles",
-	"America/Phoenix",
-	"America/Anchorage",
-	"America/Toronto",
-	"America/Vancouver",
-	"America/Mexico_City",
-	"America/Sao_Paulo",
-	"America/Buenos_Aires",
-	"Europe/London",
-	"Europe/Paris",
-	"Europe/Berlin",
-	"Europe/Rome",
-	"Europe/Madrid",
-	"Europe/Amsterdam",
-	"Europe/Stockholm",
-	"Europe/Vienna",
-	"Europe/Zurich",
-	"Europe/Moscow",
-	"Europe/Athens",
-	"Europe/Dublin",
-	"Asia/Tokyo",
-	"Asia/Shanghai",
-	"Asia/Hong_Kong",
-	"Asia/Singapore",
-	"Asia/Seoul",
-	"Asia/Dubai",
-	"Asia/Kolkata",
-	"Asia/Bangkok",
-	"Asia/Jakarta",
-	"Asia/Manila",
-	"Asia/Taipei",
-	"Australia/Sydney",
-	"Australia/Melbourne",
-	"Australia/Brisbane",
-	"Australia/Perth",
-	"Australia/Adelaide",
-	"Pacific/Auckland",
-	"Pacific/Honolulu",
-	"Africa/Cairo",
-	"Africa/Johannesburg",
-	"Africa/Lagos",
-	"Africa/Nairobi",
-	"Asia/Riyadh",
-	"Asia/Tehran",
-	"Asia/Jerusalem",
-	"Asia/Doha"
-]);
-//#endregion
-//#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-deploy-DmpCWE3u.mjs

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

package/dist/trigger-manifest-Bq2zRbkV.mjs

@@ -1,29 +0,0 @@
-#!/usr/bin/env node
-
-import { a as TriggerCredentialRequirementsSchema, l as WebhookMethodSchema, o as TriggerSourceSchema, s as TriggerTypeSchema } from "./credential-requirements-DrrQ9x9P.mjs";
-import { z } from "zod";
-//#region ../../packages/shared-types/src/workflows/build-output/trigger-manifest.ts
-const TriggerBuildFunctionSchema = z.object({
-	js: z.string().min(1),
-	export: z.string().min(1)
-});
-const TriggerBuildManifestSchema = z.object({
-	id: z.string().min(1),
-	type: TriggerTypeSchema,
-	/**
-	* Webhook source discriminator (`'custom' | 'app'`). Undefined for
-	* non-webhook triggers.
-	*/
-	triggerSource: TriggerSourceSchema.optional(),
-	enabled: z.boolean().default(true),
-	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(),
-	functions: z.record(z.string(), TriggerBuildFunctionSchema).optional(),
-	attachmentFunctions: z.record(z.string(), TriggerBuildFunctionSchema).optional()
-});
-//#endregion
-export { TriggerBuildManifestSchema as t };