@keystrokehq/cli 0.0.1

package/dist/test.handler-BcPQ8b74.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+import { t as ui } from "./keystroke.mjs";
+import { a as validateApiKey, i as requireClient } from "./context-T7HZuB97.mjs";
+//#region src/commands/auth/test.handler.ts
+async function handleAuthTest(_options, ctx) {
+	const result = await validateApiKey(requireClient(ctx));
+	ui.success("API key is valid.");
+	ui.hint(`  Organization: ${result.organizationId}`);
+	ui.hint(`  Key ID: ${result.apiKeyId}`);
+}
+//#endregion
+export { handleAuthTest };

package/dist/trigger-artifacts-DQPbQNqC-B4yeeFBY.mjs

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+
+import { n as readOptionalJsonSchemaKeys } from "./_manifest-JSRE3H8k.mjs";
+import { t as __exportAll } from "./rolldown-runtime-twds-ZHy-BWWzu8VG.mjs";
+import { t as readCredentialKeysFromSchemaObject } from "./read-credential-keys-77a91T8M-KA0Iw0Z1.mjs";
+import { r as formatEnvAccessError, t as createEnvAccessPlugin } from "./detect-env-access-CwkOYeYM-D_BCZqV6.mjs";
+import { createHash } from "node:crypto";
+import { rolldown } from "rolldown";
+//#region ../../packages/workflow-builder/dist/trigger-artifacts-DQPbQNqC.mjs
+async function bundleTriggerCallbacks(options) {
+	return bundleCallbacks(options.filePath, options.projectRoot, options.exportNames, options.triggerExportName, options.workflowExtraction);
+}
+async function bundleAttachmentCallbacks(options) {
+	return bundleCallbacks(options.filePath, options.projectRoot, options.exportNames, void 0, options.workflowExtraction);
+}
+async function bundleCallbacks(filePath, projectRoot, exportNames, triggerExportName, workflowExtraction) {
+	const entryId = "\0virtual:trigger-callback-entry";
+	const accessorExpr = (base, name) => `${base}.${name} ?? ${base}.trigger?.${name} ?? ${base}.source?.${name} ?? ${base}.trigger?.source?.${name}`;
+	let reExports;
+	if (workflowExtraction) {
+		const { workflowExportName, workflowFilePath, triggerIndex } = workflowExtraction;
+		const base = `__wf.triggers[${triggerIndex}]`;
+		reExports = [`import { ${workflowExportName} as __wf } from ${JSON.stringify(workflowFilePath)};`, ...exportNames.map((name) => `export const ${name} = ${accessorExpr(base, name)};`)].join("\n");
+	} else if (triggerExportName) reExports = [`import { ${triggerExportName} as __trigger } from ${JSON.stringify(filePath)};`, ...exportNames.map((name) => `export const ${name} = ${accessorExpr("__trigger", name)};`)].join("\n");
+	else reExports = exportNames.map((name) => `export { ${name} } from ${JSON.stringify(filePath)};`).join("\n");
+	const envViolations = [];
+	const bundle = await rolldown({
+		input: entryId,
+		platform: "node",
+		external: [
+			/^node:/,
+			"@swc/core",
+			/^@swc\/core-/,
+			/^@swc\/wasm/
+		],
+		plugins: [createEnvAccessPlugin(envViolations, projectRoot), {
+			name: "trigger-callback-entry",
+			resolveId(source) {
+				if (source === entryId) return entryId;
+				return null;
+			},
+			load(id) {
+				if (id === entryId) return reExports;
+				return null;
+			}
+		}]
+	});
+	try {
+		const { output } = await bundle.generate({
+			codeSplitting: false,
+			format: "esm",
+			sourcemap: false
+		});
+		if (envViolations.length > 0) throw new Error(formatEnvAccessError(envViolations));
+		const chunks = output.filter((candidate) => candidate.type === "chunk");
+		if (chunks.length !== 1) throw new Error(`Trigger callback bundle must produce exactly one chunk for ${filePath}`);
+		const [chunk] = chunks;
+		if (!chunk) throw new Error(`Expected rolldown to generate a chunk for trigger callbacks in ${filePath}`);
+		return {
+			code: chunk.code,
+			size: Buffer.byteLength(chunk.code),
+			hash: createHash("sha256").update(chunk.code).digest("hex")
+		};
+	} finally {
+		await bundle.close();
+	}
+}
+var trigger_artifacts_exports = /* @__PURE__ */ __exportAll({
+	buildTriggerArtifacts: () => buildTriggerArtifacts,
+	generateTriggerId: () => generateTriggerId
+});
+function generateTriggerId(workflowId, triggerName) {
+	return createHash("sha256").update(`${workflowId}::${triggerName}`).digest("hex").slice(0, 16);
+}
+async function buildTriggerArtifacts(loadedTriggers, workflowId, workflowName, projectRoot, workflowContext) {
+	const artifacts = [];
+	const triggerFailures = [];
+	for (const loaded of loadedTriggers) {
+		const triggerManifest = loaded.triggerManifest;
+		const triggerName = triggerManifest.name;
+		const triggerType = triggerManifest.triggerType;
+		const runtime = triggerManifest.runtime;
+		const callbacks = runtime.callbacks;
+		const triggerId = generateTriggerId(workflowId, triggerName);
+		const webhookSource = "source" in runtime && runtime.source && typeof runtime.source === "object" ? runtime.source : null;
+		const projectedConfig = webhookSource ? webhookSource.type === "app" ? { source: {
+			type: "app",
+			appRef: webhookSource.appRef
+		} } : { source: {
+			type: "custom",
+			method: webhookSource.method,
+			path: webhookSource.path,
+			...webhookSource.response ? { response: webhookSource.response } : {}
+		} } : void 0;
+		const artifact = {
+			triggerId,
+			triggerType,
+			triggerName,
+			workflowId,
+			workflowName,
+			sourceFilePath: loaded.sourceFilePath,
+			hasTransform: loaded.hasTransform,
+			hasFilter: loaded.hasFilter,
+			enabled: triggerManifest.enabled,
+			..."schedule" in runtime && typeof runtime.schedule === "string" ? { schedule: runtime.schedule } : {},
+			..."timezone" in runtime && typeof runtime.timezone === "string" ? { timezone: runtime.timezone } : {},
+			...webhookSource ? { triggerSource: webhookSource.type } : {},
+			...webhookSource?.type === "custom" && webhookSource.path ? { path: webhookSource.path } : {},
+			...webhookSource?.type === "custom" && webhookSource.method ? { method: webhookSource.method } : {},
+			...projectedConfig ? { config: projectedConfig } : {},
+			...triggerManifest.modeDefault ? { modeDefault: triggerManifest.modeDefault } : {},
+			...triggerManifest.credentialSets ? { requiredCredentials: buildTriggerCredentialRequirements(triggerManifest.credentialSets, callbacks) } : {},
+			...loaded.staticPayload !== void 0 ? { staticPayload: loaded.staticPayload } : {},
+			trigger: loaded.triggerManifest
+		};
+		if (callbacks) {
+			const callbackEntries = [];
+			if (callbacks.verify) callbackEntries.push({
+				exportName: "verify",
+				manifestKey: "verify"
+			});
+			if (callbacks.filter) callbackEntries.push({
+				exportName: "filter",
+				manifestKey: "filter"
+			});
+			if (callbacks.idempotencyKey) callbackEntries.push({
+				exportName: "idempotencyKey",
+				manifestKey: "idempotencyKey"
+			});
+			if (callbacks.poll) callbackEntries.push({
+				exportName: "poll",
+				manifestKey: "callback"
+			});
+			if (callbackEntries.length > 0) try {
+				artifact.callbackBundle = await bundleTriggerCallbacks({
+					filePath: loaded.sourceFilePath,
+					projectRoot,
+					exportNames: callbackEntries.map((entry) => entry.exportName),
+					triggerExportName: loaded.triggerExportName,
+					...workflowContext ? { workflowExtraction: {
+						workflowExportName: workflowContext.workflowExportName,
+						workflowFilePath: workflowContext.workflowFilePath,
+						triggerIndex: loaded.triggerIndex
+					} } : {}
+				});
+				artifact.callbackExports = Object.fromEntries(callbackEntries.map((entry) => [entry.manifestKey, entry.exportName]));
+			} catch (error) {
+				triggerFailures.push({
+					kind: "trigger",
+					triggerName,
+					triggerExportName: loaded.triggerExportName ?? "unknown",
+					workflowId,
+					phase: "callback-bundle",
+					error: error instanceof Error ? error.message : String(error)
+				});
+			}
+		}
+		if (loaded.hasTransform) {
+			let transformBundled = false;
+			let bundleError;
+			if (workflowContext) try {
+				artifact.transformCallbackBundle = await bundleAttachmentCallbacks({
+					filePath: loaded.sourceFilePath,
+					projectRoot,
+					exportNames: ["transform"],
+					workflowExtraction: {
+						workflowExportName: workflowContext.workflowExportName,
+						workflowFilePath: workflowContext.workflowFilePath,
+						triggerIndex: loaded.triggerIndex
+					}
+				});
+				artifact.transformCallbackExports = { transform: "transform" };
+				transformBundled = true;
+			} catch (err) {
+				bundleError = err;
+			}
+			if (!transformBundled) try {
+				artifact.transformCallbackBundle = await bundleAttachmentCallbacks({
+					filePath: loaded.sourceFilePath,
+					projectRoot,
+					exportNames: ["transform"]
+				});
+				artifact.transformCallbackExports = { transform: "transform" };
+				transformBundled = true;
+			} catch (err) {
+				bundleError = bundleError ?? err;
+			}
+			if (!transformBundled) {
+				const cause = bundleError instanceof Error ? `: ${bundleError.message}` : "";
+				triggerFailures.push({
+					kind: "trigger",
+					triggerName,
+					triggerExportName: loaded.triggerExportName ?? "unknown",
+					workflowId,
+					phase: "callback-bundle",
+					error: `Transform declared on trigger "${triggerName}" but could not be bundled${cause}. Ensure the workflow is exported or the transform is a standalone export.`
+				});
+			}
+		}
+		artifacts.push(artifact);
+	}
+	return {
+		artifacts,
+		failures: triggerFailures
+	};
+}
+function buildTriggerCredentialRequirements(credentialSets, callbacks) {
+	if (!credentialSets || credentialSets.length === 0) return {
+		required: [],
+		byCallback: {}
+	};
+	const entries = credentialSets.map((credentialSet) => {
+		const optionalCredentialKeys = readOptionalJsonSchemaKeys(credentialSet.auth);
+		const storedSchema = credentialSet.stored ?? credentialSet.auth;
+		const storedCredentialKeys = readCredentialKeysFromSchemaObject(storedSchema);
+		const optionalStoredCredentialKeys = readOptionalJsonSchemaKeys(storedSchema);
+		const resolveCacheMs = "resolveCacheMs" in credentialSet && typeof credentialSet.resolveCacheMs === "number" ? credentialSet.resolveCacheMs : void 0;
+		const topLevelRevoked = "onCredentialRevoked" in credentialSet ? credentialSet.onCredentialRevoked : void 0;
+		return {
+			credentialSetId: credentialSet.resolvedCredentialSetId,
+			credentialKeys: readCredentialKeysFromSchemaObject(credentialSet.auth),
+			...optionalCredentialKeys.length > 0 ? { optionalCredentialKeys } : {},
+			...storedCredentialKeys.length > 0 ? { storedCredentialKeys } : {},
+			...optionalStoredCredentialKeys.length > 0 ? { optionalStoredCredentialKeys } : {},
+			...typeof resolveCacheMs === "number" && resolveCacheMs > 0 ? { resolveCacheMs } : {},
+			...topLevelRevoked ? { onCredentialRevoked: topLevelRevoked } : {}
+		};
+	});
+	const requiredIds = credentialSets.map((credentialSet) => credentialSet.resolvedCredentialSetId);
+	const byCallback = {};
+	if (callbacks?.poll) byCallback.callback = entries;
+	if (callbacks?.verify) byCallback.verify = entries;
+	return {
+		required: requiredIds,
+		byCallback
+	};
+}
+//#endregion
+export { trigger_artifacts_exports as n, buildTriggerArtifacts as t };

package/dist/trigger-manifest-CY7brZeg.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+import { d as TriggerSourceSchema, f as TriggerTypeSchema, m as WebhookMethodSchema, u as TriggerCredentialRequirementsSchema } from "./schedule-BXx3uXwr.mjs";
+import "./_manifest-JSRE3H8k.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 };