@keystrokehq/cli 0.0.1

package/dist/sync.handler-BUFPdzWz.mjs

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+import { D as throwReportedCliExit, h as toErrorMessage, i as logger, t as ui } from "./keystroke.mjs";
+import { d as trackProject } from "./dist-CUK7yBM0.mjs";
+import { n as deployFromDir } from "./dist-BkJUoBiG.mjs";
+import { t as requireWorkflowsDir } from "./resolve-project-DDJ29sCF.mjs";
+import { a as runWorkflowBuild, n as renderBuildFailure, r as renderBuildHeader } from "./workflow-build-DBQaBfnn.mjs";
+import { r as isLocalMode } from "./env-91KwMKov.mjs";
+import { a as validateApiKey, i as requireClient } from "./context-T7HZuB97.mjs";
+import { t as createBuildProgress } from "./build-progress-DgYKb4hB.mjs";
+import { t as createDeployProgress } from "./deploy-progress-BmGUNFKg.mjs";
+//#region src/commands/sync/sync.handler.ts
+async function handleSync(options, ctx) {
+	try {
+		await runSingleSync(options, ctx);
+		if (!options.watch) return;
+		ui.hint("Watching for changes. Press Ctrl+C to stop.");
+		const keepAlive = setInterval(() => {}, 1e3);
+		await new Promise(() => keepAlive);
+	} catch (error) {
+		const message = toErrorMessage(error);
+		logger.error("Sync error", { error: message });
+		ui.error(`Sync error: ${message}`);
+		throwReportedCliExit(`Sync error: ${message}`, { cause: error });
+	}
+}
+async function runSingleSync(options, ctx) {
+	const workflowsDir = await requireWorkflowsDir();
+	trackProject(workflowsDir);
+	const client = requireClient(ctx);
+	await validateApiKey(client);
+	logger.info("Starting sync", {
+		workflowsDir,
+		force: options.force,
+		watch: options.watch
+	});
+	renderBuildHeader();
+	const buildProgress = createBuildProgress("workflow");
+	let outDir;
+	try {
+		outDir = (await runWorkflowBuild({
+			workflowsDir,
+			verbose: false,
+			force: options.force,
+			onProgressEvent: buildProgress.handleEvent
+		})).outDir;
+	} catch (error) {
+		renderBuildFailure(error);
+		throwReportedCliExit("Build failed during sync.", { cause: error });
+	} finally {
+		buildProgress.stop();
+	}
+	const deployProgress = createDeployProgress();
+	try {
+		const result = await deployFromDir({
+			outDir,
+			workflowsDir,
+			client,
+			isLocalMode: isLocalMode(),
+			force: options.force,
+			onDeployProgressEvent: deployProgress.handleEvent
+		});
+		if (!result.success) {
+			ui.error("Sync failed during deploy.");
+			throwReportedCliExit("Sync failed during deploy.");
+		}
+		const deployedWorkflows = result.workflows.filter((workflow) => workflow.status === "deployed");
+		const deployedAgents = result.agents.filter((agent) => agent.status === "deployed");
+		if (deployedWorkflows.length === 0 && deployedAgents.length === 0) {
+			ui.success("Sync complete. All workflows and agents are up to date.");
+			return;
+		}
+		const parts = [];
+		if (deployedWorkflows.length > 0) parts.push(`${deployedWorkflows.length} workflow(s)`);
+		if (deployedAgents.length > 0) parts.push(`${deployedAgents.length} agent(s)`);
+		ui.success(`Sync complete. Deployed ${parts.join(" and ")}.`);
+	} finally {
+		deployProgress.stop();
+	}
+}
+//#endregion
+export { handleSync };

package/dist/task-B2sZMaZu.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { n as __exportAll } from "./chunk-CH6r78ws.mjs";
+import { t as TaskBuildManifestSchema } from "./schemas-CDib1RhE.mjs";
+//#region ../../packages/workflow-core/src/task/index.ts
+var task_exports = /* @__PURE__ */ __exportAll({ TaskBuildManifestSchema: () => TaskBuildManifestSchema });
+//#endregion
+export { task_exports as t };

package/dist/task-target-build-CBeCKbu2.mjs

@@ -0,0 +1,432 @@
+#!/usr/bin/env node
+
+import { t as readCredentialKeysFromSchemaObject } from "./read-credential-keys-77a91T8M-KA0Iw0Z1.mjs";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { createHash, randomUUID } from "node:crypto";
+//#region ../../packages/workflow-builder/dist/builder-options-BT2McCyF.mjs
+function createBuilderBundleOptions(options) {
+	return { sourceMaps: options.disableSourcemaps !== true };
+}
+//#endregion
+//#region ../../packages/workflow-builder/dist/task-target-build.mjs
+const TASK_METADATA_BUNDLE_EXTERNALS = [
+	/^node:/,
+	"@swc/core",
+	/^@swc\/core-/,
+	/^@swc\/wasm/,
+	"playwright-core",
+	/^@keystroke\//,
+	"zod"
+];
+async function buildTaskTargets(options) {
+	const builtTasks = await buildTaskTargetEntries(options);
+	const { preparedTasks, failures } = await prepareTaskTargetBuiltTasks({
+		builtTasks,
+		projectRoot: options.projectRoot,
+		retainBuiltTasks: options.retainBuiltTasks
+	});
+	return {
+		builtTasks: options.retainBuiltTasks ? builtTasks : [],
+		preparedTasks,
+		failures
+	};
+}
+async function buildTaskTargetEntries(options) {
+	const targetFiles = resolveTaskTargetFiles(options);
+	const bundleOptions = createBuilderBundleOptions(options);
+	const builtTasks = [];
+	for (const targetFile of targetFiles) {
+		const builtTargetTasks = await buildTaskTargetFile({
+			targetFile,
+			projectRoot: options.projectRoot,
+			sourceMaps: bundleOptions.sourceMaps
+		});
+		builtTasks.push(...builtTargetTasks);
+	}
+	return builtTasks;
+}
+async function prepareTaskTargetBuiltTasks(options) {
+	const failures = [];
+	for (const builtTask of options.builtTasks) failures.push(...await attachTaskTargetTriggers({
+		artifact: builtTask.artifact,
+		entry: builtTask.entry,
+		projectRoot: options.projectRoot
+	}));
+	const preparedTasks = failures.length === 0 ? await prepareTaskTargetOutput({ builtTasks: options.builtTasks }) : [];
+	if (!options.retainBuiltTasks) releaseBuiltTaskTargets(options.builtTasks);
+	return {
+		preparedTasks,
+		failures
+	};
+}
+function resolveTaskTargetFiles(options) {
+	const projectRoot = path.resolve(options.projectRoot);
+	if (options.targetFiles.length === 0) throw new Error("Target-only task deploy requires at least one --target file.");
+	return [...new Set(options.targetFiles.map((targetFile) => path.resolve(path.isAbsolute(targetFile) ? targetFile : path.join(projectRoot, targetFile))))].sort((left, right) => left.localeCompare(right));
+}
+async function buildTaskTargetFile(options) {
+	const runtimeBundlePath = getTaskRuntimeBundlePath(options.projectRoot, { bindingKey: options.targetFile });
+	const bundle = await bundleTaskTargetModule({
+		filePath: options.targetFile,
+		projectRoot: options.projectRoot,
+		sourceMap: options.sourceMaps
+	});
+	await writeRuntimeBundle(runtimeBundlePath, bundle.code);
+	bundle.code = "";
+	const moduleUrl = pathToFileURL(runtimeBundlePath);
+	moduleUrl.searchParams.set("keystrokeTaskMetadata", randomUUID());
+	const importedModule = await import(moduleUrl.href);
+	const builtTasks = [];
+	for (const [moduleExportName, exportedValue] of Object.entries(importedModule).sort(([left], [right]) => left.localeCompare(right))) {
+		if (!isTaskLike(exportedValue)) continue;
+		const exportName = moduleExportName === "__default" ? "default" : moduleExportName;
+		const manifest = await tryParseTaskBuildManifest(exportedValue.toManifest());
+		if (!manifest) continue;
+		const source = createTaskTargetSource({
+			projectRoot: options.projectRoot,
+			targetFile: options.targetFile,
+			exportName,
+			localExportName: moduleExportName
+		});
+		const taskMetadata = {
+			manifest,
+			triggers: discoverTaskTriggers(exportedValue, importedModule, options.targetFile),
+			timing: {
+				importMs: 0,
+				manifestMs: 0
+			}
+		};
+		builtTasks.push(createBuiltTaskTarget({
+			source,
+			taskMetadata,
+			runtimeBundlePath,
+			bundle
+		}));
+	}
+	if (builtTasks.length === 0) throw new Error(`No task exports were discovered for target ${options.targetFile}.`);
+	return builtTasks;
+}
+async function bundleTaskTargetModule(options) {
+	const [{ rolldown }, { createEnvAccessPlugin, formatEnvAccessError }] = await Promise.all([import("rolldown"), import("./detect-env-access-CwkOYeYM-D_BCZqV6.mjs").then((n) => n.n).then((n) => n.n)]);
+	const entryId = "\0virtual:task-target-entry";
+	const trackedDependencies = /* @__PURE__ */ new Set();
+	const envViolations = [];
+	const exportReference = [
+		`import * as __taskTargetModule from ${JSON.stringify(options.filePath)};`,
+		`export * from ${JSON.stringify(options.filePath)};`,
+		"export const __default = __taskTargetModule.default;"
+	].join("\n");
+	const bundle = await rolldown({
+		input: entryId,
+		platform: "node",
+		external: [...TASK_METADATA_BUNDLE_EXTERNALS],
+		plugins: [createEnvAccessPlugin(envViolations, options.projectRoot), {
+			name: "task-target-entry",
+			resolveId(source) {
+				if (source === entryId) return entryId;
+				return null;
+			},
+			load(id) {
+				if (id === entryId) return exportReference;
+				return null;
+			},
+			moduleParsed(moduleInfo) {
+				if (!moduleInfo.id.includes("node_modules") && !moduleInfo.id.includes("\0")) trackedDependencies.add(moduleInfo.id);
+			}
+		}]
+	});
+	try {
+		const { output } = await bundle.generate({
+			codeSplitting: false,
+			format: "esm",
+			sourcemap: options.sourceMap
+		});
+		if (envViolations.length > 0) throw new Error(formatEnvAccessError(envViolations));
+		const chunks = output.filter((candidate) => candidate.type === "chunk");
+		if (chunks.length !== 1) throw new Error(`Task target bundle must produce exactly one chunk for ${options.filePath}`);
+		const [chunk] = chunks;
+		if (!chunk) throw new Error(`Expected rolldown to generate a chunk for ${options.filePath}`);
+		const sourceMap = chunk.map ? chunk.map.toString() : null;
+		return {
+			code: chunk.code,
+			sourceMap,
+			hash: createHash("sha256").update(chunk.code).digest("hex"),
+			...sourceMap ? { sourceMapHash: createHash("sha256").update(sourceMap).digest("hex") } : {},
+			localDependencies: Array.from(trackedDependencies).sort((left, right) => left.localeCompare(right)),
+			externalImports: [...new Set([...chunk.imports, ...chunk.dynamicImports])].sort((left, right) => left.localeCompare(right)),
+			size: Buffer.byteLength(chunk.code)
+		};
+	} finally {
+		await bundle.close();
+	}
+}
+function createBuiltTaskTarget(options) {
+	const manifestData = options.taskMetadata.manifest;
+	return {
+		artifact: {
+			task: {
+				bindingKey: options.source.bindingKey,
+				exportFilePath: options.source.exportFilePath,
+				resolvedFilePath: options.source.resolvedFilePath,
+				exportName: options.source.exportName,
+				localExportName: options.source.localExportName,
+				taskId: manifestData.id,
+				taskName: manifestData.name
+			},
+			manifest: manifestData,
+			bundle: {
+				code: "",
+				sourceMap: options.bundle.sourceMap,
+				hash: options.bundle.hash,
+				sourceMapHash: options.bundle.sourceMapHash,
+				localDependencies: options.bundle.localDependencies,
+				externalImports: options.bundle.externalImports,
+				size: options.bundle.size
+			},
+			triggers: [],
+			timing: {
+				importMs: options.taskMetadata.timing.importMs,
+				manifestMs: options.taskMetadata.timing.manifestMs,
+				bundleMs: 0,
+				triggerMs: 0,
+				totalMs: 0
+			}
+		},
+		entry: {
+			source: options.source,
+			taskMetadata: options.taskMetadata,
+			runtimeBundlePath: options.runtimeBundlePath
+		}
+	};
+}
+function createTaskTargetSource(options) {
+	const resolvedFilePath = path.resolve(options.targetFile);
+	return {
+		bindingKey: `${path.relative(options.projectRoot, resolvedFilePath)}#${options.exportName}`,
+		exportFilePath: path.relative(options.projectRoot, resolvedFilePath),
+		resolvedFilePath,
+		exportName: options.exportName,
+		localExportName: options.localExportName
+	};
+}
+async function attachTaskTargetTriggers(options) {
+	if (!hasTriggerRuntimeCallbacks(options.entry.taskMetadata.triggers)) {
+		options.artifact.triggers.push(...buildTaskTriggerArtifactsWithoutBundles(options.entry.taskMetadata.triggers, options.artifact.task.taskId, options.artifact.task.taskName));
+		return [];
+	}
+	const { buildTriggerArtifacts } = await import("./trigger-artifacts-DQPbQNqC-B4yeeFBY.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
+	});
+	options.artifact.triggers.push(...triggerResult.artifacts);
+	return triggerResult.failures;
+}
+async function prepareTaskTargetOutput(options) {
+	const preparedTasks = [];
+	for (const builtTask of options.builtTasks) {
+		const triggers = builtTask.artifact.triggers.map(toTriggerUploadData);
+		releaseTriggerBundleCode(builtTask.artifact.triggers);
+		preparedTasks.push(createPreparedTaskTarget(builtTask.artifact, triggers));
+	}
+	return preparedTasks;
+}
+function hasTriggerRuntimeCallbacks(triggers) {
+	return triggers.some((trigger) => {
+		const callbacks = trigger.triggerManifest.runtime.callbacks;
+		return trigger.hasTransform || Boolean(callbacks?.verify || callbacks?.filter || callbacks?.idempotencyKey || callbacks?.poll);
+	});
+}
+function buildTaskTriggerArtifactsWithoutBundles(loadedTriggers, workflowId, workflowName) {
+	return loadedTriggers.map((loaded) => {
+		const triggerManifest = loaded.triggerManifest;
+		const triggerName = triggerManifest.name;
+		const triggerType = triggerManifest.triggerType;
+		const runtime = triggerManifest.runtime;
+		const callbacks = runtime.callbacks;
+		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;
+		return {
+			triggerId: generateTaskTriggerId(workflowId, triggerName),
+			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: buildTaskTriggerCredentialRequirements(triggerManifest.credentialSets, callbacks) } : {},
+			...loaded.staticPayload !== void 0 ? { staticPayload: loaded.staticPayload } : {},
+			trigger: loaded.triggerManifest
+		};
+	});
+}
+function generateTaskTriggerId(workflowId, triggerName) {
+	return createHash("sha256").update(`${workflowId}::${triggerName}`).digest("hex").slice(0, 16);
+}
+function buildTaskTriggerCredentialRequirements(credentialSets, callbacks) {
+	if (!credentialSets || credentialSets.length === 0) return {
+		required: [],
+		byCallback: {}
+	};
+	const entries = credentialSets.map((credentialSet) => {
+		const optionalCredentialKeys = readOptionalJsonSchemaKeysFromSchemaObject(credentialSet.auth);
+		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 } : {},
+			...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
+	};
+}
+function createPreparedTaskTarget(artifact, triggers) {
+	return {
+		taskId: artifact.task.taskId,
+		name: artifact.task.taskName,
+		bundleHash: createHash("sha256").update(JSON.stringify(artifact.manifest)).digest("hex"),
+		bundleSize: artifact.bundle.size,
+		manifestData: artifact.manifest,
+		triggers
+	};
+}
+async function tryParseTaskBuildManifest(manifest) {
+	const { TaskBuildManifestSchema } = await import("./task-B2sZMaZu.mjs").then((n) => n.t);
+	const result = TaskBuildManifestSchema.safeParse(manifest);
+	return result.success ? result.data : null;
+}
+function readOptionalJsonSchemaKeysFromSchemaObject(schema) {
+	if (!isRecord(schema)) return [];
+	const properties = isRecord(schema.properties) ? Object.keys(schema.properties) : [];
+	const required = Array.isArray(schema.required) ? new Set(schema.required.filter((key) => typeof key === "string")) : /* @__PURE__ */ new Set();
+	return properties.filter((key) => !required.has(key));
+}
+function getTaskRuntimeBundlePath(projectRoot, target) {
+	const hash = createHash("sha256").update(target.bindingKey).digest("hex").slice(0, 16);
+	return path.join(projectRoot, ".keystroke", "task-target-build", `${hash}.mjs`);
+}
+async function writeRuntimeBundle(bundlePath, code) {
+	await mkdir(path.dirname(bundlePath), { recursive: true });
+	await writeFile(bundlePath, code, "utf-8");
+}
+function discoverTaskTriggers(task, importedModule, sourceFilePath) {
+	const triggers = [];
+	const triggerEntries = task.triggers ?? [];
+	for (let triggerIndex = 0; triggerIndex < triggerEntries.length; triggerIndex += 1) {
+		const entry = triggerEntries[triggerIndex];
+		const isBound = isBoundTriggerLike(entry);
+		const trigger = isBound ? entry.trigger : entry;
+		if (!isTriggerLike(trigger)) throw new Error(`Task trigger at index ${triggerIndex} is not manifest-capable.`);
+		const triggerManifest = trigger.toManifest();
+		const staticPayload = triggerManifest.triggerType === "cron" && hasPayload(trigger) ? trigger.payload : void 0;
+		triggers.push({
+			triggerManifest,
+			triggerExportName: findTriggerExportName(entry, trigger, importedModule),
+			sourceFilePath,
+			hasTransform: isBound && typeof entry.transform === "function",
+			hasFilter: isBound ? typeof entry.filter === "function" : typeof trigger.filter === "function",
+			staticPayload,
+			triggerIndex
+		});
+	}
+	return triggers;
+}
+function isRecord(value) {
+	return value !== null && (typeof value === "object" || typeof value === "function");
+}
+function isTaskLike(value) {
+	return isRecord(value) && typeof value.toManifest === "function";
+}
+function isTriggerLike(value) {
+	return isRecord(value) && typeof value.name === "string" && typeof value.toManifest === "function";
+}
+function isBoundTriggerLike(value) {
+	return isRecord(value) && value.isBoundTrigger === true && isTriggerLike(value.trigger);
+}
+function hasPayload(value) {
+	return isRecord(value) && "payload" in value;
+}
+function findTriggerExportName(entry, trigger, importedModule) {
+	for (const [name, value] of Object.entries(importedModule)) {
+		if (value === entry || value === trigger) return name;
+		if (isBoundTriggerLike(value) && (value === entry || value.trigger === trigger)) return name;
+		if (isTriggerLike(value) && value.name === trigger.name) return name;
+	}
+}
+function toTriggerUploadData(trigger) {
+	const callbackExports = trigger.callbackExports;
+	const transformCallbackExports = trigger.transformCallbackExports;
+	return {
+		id: trigger.triggerId,
+		type: trigger.triggerType,
+		...trigger.triggerSource ? { triggerSource: trigger.triggerSource } : {},
+		enabled: trigger.enabled,
+		...trigger.path ? { path: trigger.path } : {},
+		...trigger.method ? { method: trigger.method } : {},
+		...trigger.schedule ? { schedule: trigger.schedule } : {},
+		...trigger.timezone ? { timezone: trigger.timezone } : {},
+		...trigger.config ? { config: trigger.config } : {},
+		...trigger.requiredCredentials ? { requiredCredentials: trigger.requiredCredentials } : {},
+		...callbackExports ? { callbackExports } : {},
+		...trigger.callbackBundle ? { callbackBundle: {
+			code: trigger.callbackBundle.code,
+			hash: trigger.callbackBundle.hash ?? createHash("sha256").update(trigger.callbackBundle.code).digest("hex"),
+			size: trigger.callbackBundle.size
+		} } : {},
+		...transformCallbackExports ? { transformCallbackExports } : {},
+		...trigger.transformCallbackBundle ? { transformCallbackBundle: {
+			code: trigger.transformCallbackBundle.code,
+			hash: trigger.transformCallbackBundle.hash ?? createHash("sha256").update(trigger.transformCallbackBundle.code).digest("hex"),
+			size: trigger.transformCallbackBundle.size
+		} } : {}
+	};
+}
+function releaseTriggerBundleCode(triggers) {
+	for (const trigger of triggers) {
+		if (trigger.callbackBundle) {
+			trigger.callbackBundle.code = "";
+			trigger.callbackBundle.released = true;
+		}
+		if (trigger.transformCallbackBundle) {
+			trigger.transformCallbackBundle.code = "";
+			trigger.transformCallbackBundle.released = true;
+		}
+	}
+}
+function releaseBuiltTaskTargets(builtTasks) {
+	for (const builtTask of builtTasks) {
+		builtTask.entry.taskMetadata.triggers = [];
+		builtTask.artifact.triggers = [];
+	}
+	builtTasks.length = 0;
+}
+//#endregion
+export { buildTaskTargetEntries, buildTaskTargets, prepareTaskTargetBuiltTasks };

package/dist/task-target-deploy-C5X-USeR.mjs

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