@keystrokehq/cli 0.0.1

package/dist/writer-BG8poUm3-BbXlU2kI.mjs

@@ -0,0 +1,426 @@
+#!/usr/bin/env node
+
+import { n as __exportAll } from "./chunk-CH6r78ws.mjs";
+import { f as getTriggersDir, n as BUILD_OUTPUT_DIR_NAME, p as getWorkflowArtifactPaths, t as BUILD_DIR_NAME } from "./layout-CbMtQ2tm.mjs";
+import { t as TriggerBuildManifestSchema } from "./trigger-manifest-CY7brZeg.mjs";
+import { t as __exportAll$1 } from "./rolldown-runtime-twds-ZHy-BWWzu8VG.mjs";
+import { s as sha256String } from "./metadata-layout-GUYIUo0i-_aG2zjue.mjs";
+import { t as runWithConcurrency } from "./concurrency-gXn9Rw8x-DNl2YtrS.mjs";
+import { access, mkdir, readdir, rm, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { createHash } from "node:crypto";
+//#region ../../packages/workflow-builder/dist/writer-BG8poUm3.mjs
+var writer_BG8poUm3_exports = /* @__PURE__ */ __exportAll({
+	a: () => getAgentArtifactPaths,
+	d: () => allOutputFilesExist,
+	f: () => hashAgentManifestForDisk,
+	i: () => createAgentOutputFiles,
+	l: () => getWorkflowArtifactPaths,
+	m: () => hashWorkflowManifestForDisk,
+	n: () => resolveOutputDir,
+	o: () => removeAgentArtifacts,
+	p: () => hashWorkflowFlowForDisk,
+	r: () => AGENT_ARTIFACT_DIR_PREFIX,
+	s: () => removeWorkflowArtifacts,
+	t: () => writer_exports,
+	u: () => BUILD_CACHE_FILE_NAME
+});
+function markBundleDiskBacked(bundle, descriptor) {
+	bundle.outputPath = descriptor.outputPath;
+	if (descriptor.sourceMapPath) bundle.sourceMapPath = descriptor.sourceMapPath;
+}
+function releaseBundleCode(bundle) {
+	bundle.code = "";
+	if ("sourceMap" in bundle) bundle.sourceMap = null;
+	bundle.released = true;
+}
+function markCallbackBundleDiskBacked(bundle, outputPath) {
+	bundle.outputPath = outputPath;
+}
+function releaseCallbackBundleCode(bundle) {
+	bundle.code = "";
+	bundle.released = true;
+}
+/** Exact bytes written for workflow `manifest.json` (see `writeWorkflowArtifact`). */
+function serializeWorkflowManifestForDisk(manifest) {
+	return `${JSON.stringify(manifest, null, 2)}\n`;
+}
+/** Exact bytes written for workflow `flow.json`. */
+function serializeWorkflowFlowForDisk(flowGraph) {
+	return `${JSON.stringify(flowGraph, null, 2)}\n`;
+}
+/** Exact bytes written for agent `manifest.json`. */
+function serializeAgentManifestForDisk(manifest) {
+	return `${JSON.stringify(manifest, null, 2)}\n`;
+}
+function hashWorkflowManifestForDisk(manifest) {
+	return sha256String(serializeWorkflowManifestForDisk(manifest));
+}
+function hashWorkflowFlowForDisk(flowGraph) {
+	return sha256String(serializeWorkflowFlowForDisk(flowGraph));
+}
+function hashAgentManifestForDisk(manifest) {
+	return sha256String(serializeAgentManifestForDisk(manifest));
+}
+async function allOutputFilesExist(outputDir, outputFiles) {
+	return (await Promise.all(outputFiles.map((relativePath) => stat(path.join(outputDir, relativePath)).then(() => true, () => false)))).every(Boolean);
+}
+function workflowArtifactHashesMatch(artifact, cached) {
+	const manifestOk = hashWorkflowManifestForDisk(artifact.manifest) === cached.manifestHash;
+	const flowOk = hashWorkflowFlowForDisk(artifact.flowGraph) === cached.flowGraphHash;
+	const bundleOk = (artifact.bundle.hash ?? sha256String(artifact.bundle.code)) === cached.bundleHash;
+	const sourceMapOk = cached.sourceMapHash ? artifact.bundle.sourceMap !== null && (artifact.bundle.sourceMapHash ?? sha256String(artifact.bundle.sourceMap)) === cached.sourceMapHash : artifact.bundle.sourceMap === null;
+	return manifestOk && flowOk && bundleOk && sourceMapOk;
+}
+function agentArtifactHashesMatch(artifact, cached) {
+	const manifestOk = hashAgentManifestForDisk(artifact.manifest) === cached.manifestHash;
+	const bundleOk = (artifact.bundle.hash ?? sha256String(artifact.bundle.code)) === cached.bundleHash;
+	const sandboxPackageOk = artifact.sandboxPackage.hash === cached.sandboxPackageHash;
+	return manifestOk && bundleOk && sandboxPackageOk;
+}
+async function shouldSkipWorkflowArtifactWrite(outputDir, artifact, cached, force) {
+	if (force || !cached || artifact.triggers.length > 0) return false;
+	if (!workflowArtifactHashesMatch(artifact, cached)) return false;
+	return allOutputFilesExist(outputDir, cached.outputFiles);
+}
+async function shouldSkipAgentArtifactWrite(outputDir, artifact, cached, force) {
+	if (force || !cached) return false;
+	if (!agentArtifactHashesMatch(artifact, cached)) return false;
+	return allOutputFilesExist(outputDir, cached.outputFiles);
+}
+const BUILD_CACHE_FILE_NAME = "build-cache.json";
+async function cleanupStaleArtifacts(outputDir, currentWorkflowIds, currentAgentIds, currentTaskIds = []) {
+	const currentIds = new Set(currentWorkflowIds);
+	const currentAgentDirNames = new Set(currentAgentIds.map((agentId) => getAgentArtifactDirName(agentId)));
+	const currentTaskIds_ = new Set(currentTaskIds);
+	const entries = await readdir(outputDir, { withFileTypes: true });
+	let cleanedCount = 0;
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		if (entry.name === "build-cache.json" || entry.name === "metadata" || currentIds.has(entry.name) || currentAgentDirNames.has(entry.name) || entry.name === "tasks") continue;
+		if (!await isWorkflowArtifactDirectory(outputDir, entry.name)) {
+			if (!await isAgentArtifactDirectory(outputDir, entry.name)) continue;
+		}
+		await rm(`${outputDir}/${entry.name}`, {
+			recursive: true,
+			force: true
+		});
+		cleanedCount += 1;
+	}
+	if (currentTaskIds.length > 0) {
+		const tasksDir = `${outputDir}/${TASK_OUTPUT_DIR_NAME}`;
+		try {
+			const taskEntries = await readdir(tasksDir, { withFileTypes: true });
+			for (const taskEntry of taskEntries) if (taskEntry.isDirectory() && !currentTaskIds_.has(taskEntry.name)) {
+				await rm(`${tasksDir}/${taskEntry.name}`, {
+					recursive: true,
+					force: true
+				});
+				cleanedCount += 1;
+			}
+		} catch {}
+	}
+	return cleanedCount;
+}
+async function isWorkflowArtifactDirectory(outputDir, entryName) {
+	const paths = getWorkflowArtifactPaths(outputDir, entryName);
+	try {
+		await Promise.all([
+			access(paths.manifestPath),
+			access(paths.flowPath),
+			access(paths.bundlePath)
+		]);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function isAgentArtifactDirectory(outputDir, entryName) {
+	if (!entryName.startsWith("agent_")) return false;
+	try {
+		await Promise.all([access(`${outputDir}/${entryName}/manifest.json`), access(`${outputDir}/${entryName}/build/${AGENT_SANDBOX_PACKAGE_FILE_NAME}`)]);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function removeWorkflowArtifacts(outputDir, workflowIds) {
+	let removedCount = 0;
+	for (const workflowId of new Set(workflowIds)) {
+		await rm(getWorkflowArtifactPaths(outputDir, workflowId).workflowDir, {
+			recursive: true,
+			force: true
+		});
+		removedCount += 1;
+	}
+	return removedCount;
+}
+async function removeAgentArtifacts(outputDir, agentIds) {
+	let removedCount = 0;
+	for (const agentId of new Set(agentIds)) {
+		await rm(`${outputDir}/${getAgentArtifactDirName(agentId)}`, {
+			recursive: true,
+			force: true
+		});
+		removedCount += 1;
+	}
+	return removedCount;
+}
+/** Limits parallel dist writes so we do not overwhelm the filesystem on large projects. */
+const ARTIFACT_WRITE_CONCURRENCY = 8;
+async function writeWorkflowArtifact(artifact, outputDir, options) {
+	const artifactPaths = getWorkflowArtifactPaths(outputDir, artifact.workflow.workflowId);
+	await mkdir(artifactPaths.buildDir, { recursive: true });
+	const manifestJson = `${JSON.stringify(artifact.manifest, null, 2)}\n`;
+	const flowJson = `${JSON.stringify(artifact.flowGraph, null, 2)}\n`;
+	const writes = [
+		writeFile(artifactPaths.manifestPath, manifestJson, "utf-8"),
+		writeFile(artifactPaths.flowPath, flowJson, "utf-8"),
+		writeFile(artifactPaths.bundlePath, artifact.bundle.code, "utf-8")
+	];
+	if (artifact.bundle.sourceMap) writes.push(writeFile(artifactPaths.sourceMapPath, artifact.bundle.sourceMap, "utf-8"));
+	await Promise.all(writes);
+	markBundleDiskBacked(artifact.bundle, {
+		outputPath: artifactPaths.bundlePath,
+		size: artifact.bundle.size,
+		hash: artifact.bundle.hash,
+		...artifact.bundle.sourceMap ? { sourceMapPath: artifactPaths.sourceMapPath } : {},
+		...artifact.bundle.sourceMapHash ? { sourceMapHash: artifact.bundle.sourceMapHash } : {}
+	});
+	if (artifact.triggers.length > 0) await writeTriggerArtifacts(artifact.triggers, artifactPaths.buildDir, options);
+	if (options?.releaseBundleMemory) releaseBundleCode(artifact.bundle);
+}
+const AGENT_ARTIFACT_DIR_PREFIX = "agent_";
+const AGENT_SANDBOX_PACKAGE_FILE_NAME = "sandbox-bundle.tar.gz";
+function getAgentArtifactDirName(agentId) {
+	return `${AGENT_ARTIFACT_DIR_PREFIX}${agentId}_${createHash("sha256").update(agentId).digest("hex").slice(0, 16)}`;
+}
+function getAgentArtifactPaths(outputDir, agentId) {
+	const agentDir = path.join(outputDir, getAgentArtifactDirName(agentId));
+	const buildDir = path.join(agentDir, BUILD_DIR_NAME);
+	return {
+		agentDir,
+		buildDir,
+		manifestPath: path.join(agentDir, "manifest.json"),
+		sandboxPackagePath: path.join(buildDir, AGENT_SANDBOX_PACKAGE_FILE_NAME)
+	};
+}
+function createAgentOutputFiles(agentId) {
+	const agentDir = getAgentArtifactDirName(agentId);
+	return [path.join(agentDir, "manifest.json"), path.join(agentDir, BUILD_DIR_NAME, AGENT_SANDBOX_PACKAGE_FILE_NAME)].sort((left, right) => left.localeCompare(right));
+}
+const TASK_OUTPUT_DIR_NAME = "tasks";
+const TASK_BUNDLE_FILE_NAME = "bundle.js";
+const TASK_SOURCE_MAP_FILE_NAME = "bundle.js.map";
+function getTaskArtifactPaths(outputDir, taskId) {
+	const taskDir = path.join(outputDir, TASK_OUTPUT_DIR_NAME, taskId);
+	return {
+		taskDir,
+		buildDir: path.join(taskDir, "build"),
+		manifestPath: path.join(taskDir, "manifest.json"),
+		bundlePath: path.join(taskDir, TASK_BUNDLE_FILE_NAME),
+		sourceMapPath: path.join(taskDir, TASK_SOURCE_MAP_FILE_NAME)
+	};
+}
+async function writeTaskArtifact(artifact, outputDir, options) {
+	const artifactPaths = getTaskArtifactPaths(outputDir, artifact.task.taskId);
+	await mkdir(artifactPaths.taskDir, { recursive: true });
+	const manifestJson = `${JSON.stringify(artifact.manifest, null, 2)}\n`;
+	const writes = [writeFile(artifactPaths.manifestPath, manifestJson, "utf-8"), writeFile(artifactPaths.bundlePath, artifact.bundle.code, "utf-8")];
+	if (artifact.bundle.sourceMap) writes.push(writeFile(artifactPaths.sourceMapPath, artifact.bundle.sourceMap, "utf-8"));
+	await Promise.all(writes);
+	markBundleDiskBacked(artifact.bundle, {
+		outputPath: artifactPaths.bundlePath,
+		size: artifact.bundle.size,
+		hash: artifact.bundle.hash,
+		...artifact.bundle.sourceMap ? { sourceMapPath: artifactPaths.sourceMapPath } : {},
+		...artifact.bundle.sourceMapHash ? { sourceMapHash: artifact.bundle.sourceMapHash } : {}
+	});
+	if (artifact.triggers.length > 0) await writeTriggerArtifacts(artifact.triggers, artifactPaths.buildDir, options);
+	if (options?.releaseBundleMemory) releaseBundleCode(artifact.bundle);
+}
+async function writeAgentArtifact(artifact, outputDir, options) {
+	const artifactPaths = getAgentArtifactPaths(outputDir, artifact.agent.agentId);
+	await mkdir(artifactPaths.buildDir, { recursive: true });
+	const manifestJson = `${JSON.stringify(artifact.manifest, null, 2)}\n`;
+	const writes = [writeFile(artifactPaths.manifestPath, manifestJson, "utf-8"), writeFile(artifactPaths.sandboxPackagePath, artifact.sandboxPackage.buffer)];
+	await Promise.all(writes);
+	markBundleDiskBacked(artifact.bundle, {
+		outputPath: artifactPaths.sandboxPackagePath,
+		size: artifact.bundle.size,
+		hash: artifact.bundle.hash
+	});
+	if (options?.releaseBundleMemory) releaseBundleCode(artifact.bundle);
+}
+async function writeBuildOutput(result, outputDir, options) {
+	validateArtifactsForWrite(result.artifacts);
+	await mkdir(outputDir, { recursive: true });
+	const canSkipWrites = options?.buildCache !== void 0 && options.skipUnchangedWrites !== false && options?.force !== true;
+	let skippedWriteCount = 0;
+	const resolvedKeys = options?.cacheResolvedBindingKeys;
+	await runWithConcurrency(result.artifacts, ARTIFACT_WRITE_CONCURRENCY, async (artifact) => {
+		if (canSkipWrites) {
+			if (resolvedKeys?.has(artifact.workflow.bindingKey) && artifact.triggers.length === 0) {
+				skippedWriteCount += 1;
+				return;
+			}
+			const cached = options?.buildCache?.bindings[artifact.workflow.bindingKey];
+			if (await shouldSkipWorkflowArtifactWrite(outputDir, artifact, cached, false)) {
+				skippedWriteCount += 1;
+				return;
+			}
+		}
+		await writeWorkflowArtifact(artifact, outputDir, options);
+	});
+	await runWithConcurrency(result.agentArtifacts, ARTIFACT_WRITE_CONCURRENCY, async (agentArtifact) => {
+		if (canSkipWrites) {
+			if (resolvedKeys?.has(agentArtifact.agent.bindingKey)) {
+				skippedWriteCount += 1;
+				return;
+			}
+			const cached = options?.buildCache?.agentBindings[agentArtifact.agent.bindingKey];
+			if (await shouldSkipAgentArtifactWrite(outputDir, agentArtifact, cached, false)) {
+				skippedWriteCount += 1;
+				return;
+			}
+		}
+		await writeAgentArtifact(agentArtifact, outputDir, options);
+	});
+	const taskArtifacts = result.taskArtifacts;
+	await runWithConcurrency(taskArtifacts, ARTIFACT_WRITE_CONCURRENCY, async (taskArtifact) => {
+		await writeTaskArtifact(taskArtifact, outputDir, options);
+	});
+	const cleanedCount = await cleanupStaleArtifacts(outputDir, result.artifacts.map((artifact) => artifact.workflow.workflowId), result.agentArtifacts.map((artifact) => artifact.agent.agentId), taskArtifacts.map((artifact) => artifact.task.taskId));
+	return {
+		writtenCount: result.artifacts.length + result.agentArtifacts.length + taskArtifacts.length,
+		cleanedCount,
+		outputDir,
+		artifacts: [...result.artifacts],
+		...skippedWriteCount > 0 ? { skippedWriteCount } : {}
+	};
+}
+async function writeTargetedBuildOutput(result, outputDir, previousWorkflowIds, options) {
+	validateArtifactsForWrite(result.artifacts);
+	await mkdir(outputDir, { recursive: true });
+	const canSkipWrites = options?.buildCache !== void 0 && options.skipUnchangedWrites !== false && options?.force !== true;
+	let skippedWriteCount = 0;
+	const resolvedKeys = options?.cacheResolvedBindingKeys;
+	await runWithConcurrency(result.artifacts, ARTIFACT_WRITE_CONCURRENCY, async (artifact) => {
+		if (canSkipWrites) {
+			if (resolvedKeys?.has(artifact.workflow.bindingKey) && artifact.triggers.length === 0) {
+				skippedWriteCount += 1;
+				return;
+			}
+			const cached = options?.buildCache?.bindings[artifact.workflow.bindingKey];
+			if (await shouldSkipWorkflowArtifactWrite(outputDir, artifact, cached, false)) {
+				skippedWriteCount += 1;
+				return;
+			}
+		}
+		await writeWorkflowArtifact(artifact, outputDir, options);
+	});
+	await runWithConcurrency(result.agentArtifacts, ARTIFACT_WRITE_CONCURRENCY, async (agentArtifact) => {
+		if (canSkipWrites) {
+			if (resolvedKeys?.has(agentArtifact.agent.bindingKey)) {
+				skippedWriteCount += 1;
+				return;
+			}
+			const cached = options?.buildCache?.agentBindings[agentArtifact.agent.bindingKey];
+			if (await shouldSkipAgentArtifactWrite(outputDir, agentArtifact, cached, false)) {
+				skippedWriteCount += 1;
+				return;
+			}
+		}
+		await writeAgentArtifact(agentArtifact, outputDir, options);
+	});
+	const taskArtifacts = result.taskArtifacts;
+	await runWithConcurrency(taskArtifacts, ARTIFACT_WRITE_CONCURRENCY, async (taskArtifact) => {
+		await writeTaskArtifact(taskArtifact, outputDir, options);
+	});
+	const currentWorkflowIds = new Set(result.artifacts.map((artifact) => artifact.workflow.workflowId));
+	const cleanedCount = await removeWorkflowArtifacts(outputDir, previousWorkflowIds.filter((workflowId) => !currentWorkflowIds.has(workflowId)));
+	return {
+		writtenCount: result.artifacts.length + result.agentArtifacts.length + taskArtifacts.length,
+		cleanedCount,
+		outputDir,
+		artifacts: [...result.artifacts],
+		...skippedWriteCount > 0 ? { skippedWriteCount } : {}
+	};
+}
+function toTriggerWriteArtifact(trigger, triggerDir) {
+	return {
+		triggerId: trigger.triggerId,
+		triggerDir,
+		manifestPath: path.join(triggerDir, "manifest.json"),
+		...trigger.callbackBundle ? { callbackBundlePath: path.join(triggerDir, "callback-functions.js") } : {},
+		...trigger.transformCallbackBundle ? { transformCallbackBundlePath: path.join(triggerDir, "transform.js") } : {}
+	};
+}
+async function writeTriggerArtifacts(triggers, buildDir, options) {
+	const triggersDir = getTriggersDir(buildDir);
+	try {
+		await rm(triggersDir, {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+	const results = [];
+	for (const trigger of triggers) {
+		const triggerDir = path.join(triggersDir, trigger.triggerId);
+		await mkdir(triggerDir, { recursive: true });
+		const triggerManifest = TriggerBuildManifestSchema.parse({
+			id: trigger.triggerId,
+			type: trigger.triggerType,
+			...trigger.triggerSource ? { triggerSource: trigger.triggerSource } : {},
+			enabled: trigger.enabled,
+			...trigger.schedule ? { schedule: trigger.schedule } : {},
+			...trigger.timezone ? { timezone: trigger.timezone } : {},
+			...trigger.path ? { path: trigger.path } : {},
+			...trigger.method ? { method: trigger.method } : {},
+			config: trigger.config ?? (trigger.staticPayload !== void 0 ? { payload: trigger.staticPayload } : {}),
+			...trigger.requiredCredentials ? { requiredCredentials: trigger.requiredCredentials } : {}
+		});
+		if (trigger.callbackExports && trigger.callbackBundle) triggerManifest.functions = Object.fromEntries(Object.entries(trigger.callbackExports).map(([key, exportName]) => [key, {
+			js: "callback-functions.js",
+			export: exportName
+		}]));
+		if (trigger.transformCallbackExports && trigger.transformCallbackBundle) triggerManifest.attachmentFunctions = Object.fromEntries(Object.entries(trigger.transformCallbackExports).map(([key, exportName]) => [key, {
+			js: "transform.js",
+			export: exportName
+		}]));
+		await writeFile(path.join(triggerDir, "manifest.json"), `${JSON.stringify(triggerManifest, null, 2)}\n`, "utf-8");
+		if (trigger.callbackBundle) {
+			const callbackBundlePath = path.join(triggerDir, "callback-functions.js");
+			await writeFile(callbackBundlePath, trigger.callbackBundle.code, "utf-8");
+			markCallbackBundleDiskBacked(trigger.callbackBundle, callbackBundlePath);
+			if (options?.releaseBundleMemory) releaseCallbackBundleCode(trigger.callbackBundle);
+		}
+		if (trigger.transformCallbackBundle) {
+			const transformBundlePath = path.join(triggerDir, "transform.js");
+			await writeFile(transformBundlePath, trigger.transformCallbackBundle.code, "utf-8");
+			markCallbackBundleDiskBacked(trigger.transformCallbackBundle, transformBundlePath);
+			if (options?.releaseBundleMemory) releaseCallbackBundleCode(trigger.transformCallbackBundle);
+		}
+		results.push(toTriggerWriteArtifact(trigger, triggerDir));
+	}
+	return results;
+}
+function validateArtifactsForWrite(artifacts) {
+	const workflowIdPattern = /^[^./\\][^/\\]*$/;
+	const seenIds = /* @__PURE__ */ new Set();
+	for (const artifact of artifacts) {
+		const { workflowId } = artifact.workflow;
+		if (!workflowIdPattern.test(workflowId) || workflowId.includes("..")) throw new Error(`Workflow id "${workflowId}" is not filesystem-safe`);
+		if (seenIds.has(workflowId)) throw new Error(`Duplicate workflow id "${workflowId}" detected during output validation`);
+		seenIds.add(workflowId);
+	}
+}
+function resolveOutputDir(projectRoot, config) {
+	return config?.outDir ? path.resolve(projectRoot, config.outDir) : path.join(projectRoot, BUILD_OUTPUT_DIR_NAME);
+}
+var writer_exports = /* @__PURE__ */ __exportAll$1({
+	writeBuildOutput: () => writeBuildOutput,
+	writeTargetedBuildOutput: () => writeTargetedBuildOutput
+});
+//#endregion
+export { getAgentArtifactPaths as a, hashWorkflowManifestForDisk as c, resolveOutputDir as d, writer_BG8poUm3_exports as f, createAgentOutputFiles as i, removeAgentArtifacts as l, BUILD_CACHE_FILE_NAME as n, hashAgentManifestForDisk as o, allOutputFilesExist as r, hashWorkflowFlowForDisk as s, AGENT_ARTIFACT_DIR_PREFIX as t, removeWorkflowArtifacts as u };

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@keystrokehq/cli",
+  "version": "0.0.1",
+  "private": false,
+  "description": "Command-line interface for creating, managing, and deploying Keystroke automations.",
+  "type": "module",
+  "main": "./dist/keystroke.mjs",
+  "types": "./dist/keystroke.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/keystroke.d.mts",
+      "default": "./dist/keystroke.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "keystroke": "./bin/keystroke.mjs"
+  },
+  "files": [
+    "AGENTS-blurb.md",
+    "bin",
+    "dist",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^1.2.0",
+    "cli-table3": "^0.6.5",
+    "commander": "^14.0.3",
+    "dayjs": "^1.11.20",
+    "dotenv": "^17.4.2",
+    "ky": "^1.14.3",
+    "oxc-parser": "^0.128.0",
+    "rolldown": "1.0.0-rc.17",
+    "tsx": "^4.21.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "tsdown": "0.21.10",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.5",
+    "@keystroke/env-utils": "0.0.0",
+    "@keystroke/local-memory": "0.0.0",
+    "@keystroke/project-config": "0.0.0",
+    "@keystroke/shared-types": "0.0.0",
+    "@keystroke/utils": "0.0.0",
+    "@keystroke/workflow-core": "0.0.1",
+    "@keystroke/workflow-builder": "0.0.1",
+    "@keystroke/test-utils": "0.0.0",
+    "@keystroke/workflow-deploy": "0.0.0",
+    "@keystroke/skills": "0.0.1",
+    "@keystroke/typescript-config": "0.0.0",
+    "@keystroke/workflow-sdk": "0.0.0"
+  },
+  "keywords": [
+    "automation",
+    "cli",
+    "keystroke",
+    "workflow"
+  ],
+  "homepage": "https://github.com/keystrokehq/keystroke#readme",
+  "bugs": {
+    "url": "https://github.com/keystrokehq/keystroke/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/keystrokehq/keystroke",
+    "directory": "apps/cli"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "dev:cli": "pnpm run build && node bin/keystroke.mjs",
+    "typecheck": "tsgo --build",
+    "build": "tsdown",
+    "check:command-imports": "node scripts/check-command-imports.mjs",
+    "dev:install-pack": "pnpm run build && node scripts/install-dev-pack.mjs",
+    "smoke:pack": "pnpm run build && node scripts/smoke-pack.mjs",
+    "lint": "biome check --write .",
+    "test:unit": "vitest run --passWithNoTests --project unit",
+    "test:int": "vitest run --passWithNoTests --project int"
+  }
+}