@keystrokehq/cli 0.0.1

package/dist/task-target-deploy-CA6elFpF-BEr4gkol.mjs

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+
+import { V as SHA256HashSchema } from "./schedule-BXx3uXwr.mjs";
+import "./_manifest-JSRE3H8k.mjs";
+import { createHash } from "node:crypto";
+//#region ../../packages/shared-types/src/deployments/api/snapshot-payload.ts
+function sortObjectKeysDeep(value) {
+	if (value == null) return null;
+	if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") return value;
+	if (Array.isArray(value)) return value.map((item) => sortObjectKeysDeep(item));
+	if (typeof value !== "object") return String(value);
+	const record = value;
+	const sortedEntries = Object.keys(record).sort((left, right) => left.localeCompare(right)).map((key) => [key, sortObjectKeysDeep(record[key])]);
+	return Object.fromEntries(sortedEntries);
+}
+function normalizeStepManifest(step) {
+	return sortObjectKeysDeep({
+		nodeId: step.nodeId,
+		stepName: step.stepName,
+		label: step.label,
+		callKind: step.callKind,
+		...step.stepId !== void 0 ? { stepId: step.stepId } : {},
+		...step.outputBinding !== void 0 ? { outputBinding: step.outputBinding } : {},
+		...step.scopeOverride !== void 0 ? { scopeOverride: step.scopeOverride } : {},
+		...step.description !== void 0 ? { description: step.description } : {},
+		...step.exportName !== void 0 ? { exportName: step.exportName } : {},
+		...step.importSource !== void 0 ? { importSource: step.importSource } : {},
+		...step.inputSchema !== void 0 ? { inputSchema: step.inputSchema } : {},
+		...step.outputSchema !== void 0 ? { outputSchema: step.outputSchema } : {},
+		...step.credentialSets !== void 0 ? { credentialSets: step.credentialSets } : {}
+	});
+}
+function normalizeWorkflowManifest(manifest) {
+	return sortObjectKeysDeep({
+		schemaVersion: manifest.schemaVersion,
+		name: manifest.name,
+		...manifest.description !== void 0 ? { description: manifest.description } : {},
+		...manifest.tags !== void 0 ? { tags: manifest.tags } : {},
+		id: manifest.id,
+		exportName: manifest.exportName,
+		dependencies: manifest.dependencies,
+		workflowSchemas: manifest.workflowSchemas,
+		...manifest.workflowSource !== void 0 ? { workflowSource: manifest.workflowSource } : {},
+		...manifest.workflowGlobals !== void 0 ? { workflowGlobals: manifest.workflowGlobals } : {},
+		...manifest.hasCycles !== void 0 ? { hasCycles: manifest.hasCycles } : {},
+		...manifest.credentials !== void 0 ? { credentials: manifest.credentials } : {},
+		...manifest.sandboxes !== void 0 ? { sandboxes: manifest.sandboxes } : {},
+		steps: Object.fromEntries(Object.entries(manifest.steps ?? {}).map(([nodeId, step]) => [nodeId, normalizeStepManifest(step)]))
+	});
+}
+function normalizeTrigger(trigger) {
+	return sortObjectKeysDeep({
+		id: trigger.id,
+		type: trigger.type,
+		enabled: trigger.enabled,
+		...trigger.path !== void 0 ? { path: trigger.path } : {},
+		...trigger.method !== void 0 ? { method: trigger.method } : {},
+		...trigger.schedule !== void 0 ? { schedule: trigger.schedule } : {},
+		...trigger.timezone !== void 0 ? { timezone: trigger.timezone } : {},
+		...trigger.config !== void 0 ? { config: trigger.config } : {},
+		...trigger.requiredCredentials !== void 0 ? { requiredCredentials: trigger.requiredCredentials } : {},
+		...trigger.callbackBundle ? { callbackBundleHash: trigger.callbackBundle.hash } : {},
+		...trigger.callbackExports !== void 0 ? { callbackExports: trigger.callbackExports } : {},
+		...trigger.transformCallbackBundle ? { transformCallbackBundleHash: trigger.transformCallbackBundle.hash } : {},
+		...trigger.transformCallbackExports !== void 0 ? { transformCallbackExports: trigger.transformCallbackExports } : {}
+	});
+}
+function normalizeAgentManifest(manifest) {
+	return sortObjectKeysDeep({
+		agentId: manifest.agentId,
+		agentName: manifest.agentName,
+		exportName: manifest.exportName,
+		mode: manifest.mode,
+		...manifest.runtime !== void 0 ? { runtime: manifest.runtime } : {},
+		...manifest.systemPrompt !== void 0 ? { systemPrompt: manifest.systemPrompt } : {},
+		...manifest.maxSteps !== void 0 ? { maxSteps: manifest.maxSteps } : {},
+		...manifest.enableMemory !== void 0 ? { enableMemory: manifest.enableMemory } : {},
+		...manifest.enableDatabase !== void 0 ? { enableDatabase: manifest.enableDatabase } : {},
+		...manifest.inputSchema !== void 0 ? { inputSchema: manifest.inputSchema } : {},
+		...manifest.outputSchema !== void 0 ? { outputSchema: manifest.outputSchema } : {},
+		...manifest.tools !== void 0 ? { tools: manifest.tools } : {},
+		...manifest.credentialSets !== void 0 ? { credentialSets: manifest.credentialSets } : {},
+		...manifest.sandbox !== void 0 ? { sandbox: manifest.sandbox } : {}
+	});
+}
+function buildCanonicalProjectSnapshotPayload(params) {
+	return {
+		workflows: params.workflows.map((workflow) => ({
+			workflowName: workflow.workflowName,
+			authoredWorkflowId: workflow.manifest.id,
+			bundleHash: workflow.bundleHash,
+			manifest: normalizeWorkflowManifest(workflow.manifest),
+			triggers: (workflow.triggers ?? []).map((trigger) => normalizeTrigger(trigger)).sort((left, right) => left.id.localeCompare(right.id))
+		})).sort((left, right) => left.authoredWorkflowId.localeCompare(right.authoredWorkflowId) || left.workflowName.localeCompare(right.workflowName)),
+		agents: params.agents.map((agent) => ({
+			agentId: agent.agentId,
+			agentName: agent.agentName,
+			bundleHash: agent.bundleHash,
+			manifest: normalizeAgentManifest(agent.manifest)
+		})).sort((left, right) => left.agentId.localeCompare(right.agentId) || left.agentName.localeCompare(right.agentName))
+	};
+}
+//#endregion
+//#region ../../packages/workflow-deploy/dist/task-target-deploy-CA6elFpF.mjs
+function computeProjectSnapshotHash(params) {
+	const hex = createHash("sha256").update(JSON.stringify(buildCanonicalProjectSnapshotPayload({
+		workflows: params.workflows,
+		agents: params.agents
+	}))).digest("hex");
+	return SHA256HashSchema.parse(hex);
+}
+async function deployTaskTargets(options) {
+	const startedAt = Date.now();
+	const { preparedTasks, onDeployProgressEvent } = options;
+	if (preparedTasks.length === 0) return finalizeTaskTargetResult([], startedAt);
+	if (options.dryRun) return finalizeTaskTargetResult(preparedTasks.map((task) => ({
+		name: task.name,
+		status: "skipped"
+	})), startedAt);
+	const taskArtifacts = (await lookupTaskHashes(options)).tasks || {};
+	const { tasksToDeploy, skippedTasks } = splitChangedTasks({
+		preparedTasks,
+		existingArtifacts: taskArtifacts,
+		force: options.force
+	});
+	onDeployProgressEvent?.({
+		phase: "filter",
+		status: "complete",
+		workflowsToUpload: 0,
+		workflowsSkipped: 0,
+		agentsToUpload: 0,
+		agentsSkipped: 0,
+		tasksToUpload: tasksToDeploy.length,
+		tasksSkipped: skippedTasks.length,
+		force: options.force,
+		elapsedMs: 0
+	});
+	if (tasksToDeploy.length === 0) return finalizeTaskTargetResult(skippedTasks, startedAt);
+	onDeployProgressEvent?.({
+		phase: "register-tasks",
+		status: "start",
+		count: tasksToDeploy.length
+	});
+	const registerStartedAt = Date.now();
+	let deployResult;
+	try {
+		deployResult = await options.client.public.projects.deploy({ ...buildTaskTargetDeployRequest({
+			options,
+			taskArtifacts,
+			tasksToDeploy
+		}) });
+	} finally {
+		releasePreparedTaskCallbackBundleCode(tasksToDeploy);
+	}
+	const taskResults = deployResult.tasks ?? [];
+	onDeployProgressEvent?.({
+		phase: "register-tasks",
+		status: "complete",
+		succeeded: taskResults.filter((item) => item.status === "deployed").length,
+		failed: taskResults.filter((item) => item.status === "failed").length,
+		elapsedMs: Date.now() - registerStartedAt
+	});
+	return finalizeTaskTargetResult([...skippedTasks, ...taskResults.map(mapTaskResultStatus)], startedAt);
+}
+function buildTaskTargetDeployRequest(params) {
+	return {
+		organizationId: params.options.organizationId,
+		projectId: params.options.projectId,
+		projectRoot: params.options.projectRoot,
+		scope: "targets",
+		snapshotHash: computeProjectSnapshotHash({
+			workflows: [],
+			agents: []
+		}),
+		force: params.options.force,
+		workflows: [],
+		agents: [],
+		tasks: params.tasksToDeploy.map((task) => buildTaskTargetRegistrationItem(task, params.taskArtifacts, params.options.force))
+	};
+}
+async function lookupTaskHashes(options) {
+	const hashCheckStartedAt = Date.now();
+	options.onDeployProgressEvent?.({
+		phase: "hash-check",
+		status: "start",
+		workflowCount: 0,
+		agentCount: 0,
+		taskCount: options.preparedTasks.length
+	});
+	const hashLookup = await options.client.bundles.getHashes({
+		organizationId: options.organizationId,
+		projectId: options.projectId,
+		tasks: options.preparedTasks.map((task) => ({
+			taskId: task.taskId,
+			bundleHash: task.bundleHash
+		}))
+	});
+	options.onDeployProgressEvent?.({
+		phase: "hash-check",
+		status: "complete",
+		elapsedMs: Date.now() - hashCheckStartedAt
+	});
+	return { tasks: hashLookup.tasks || {} };
+}
+function splitChangedTasks(options) {
+	if (options.force) return {
+		tasksToDeploy: options.preparedTasks,
+		skippedTasks: []
+	};
+	const tasksToDeploy = [];
+	const skippedTasks = [];
+	for (const task of options.preparedTasks) {
+		if (options.existingArtifacts[task.taskId]?.bundleHash === task.bundleHash) {
+			skippedTasks.push({
+				name: task.name,
+				status: "skipped"
+			});
+			continue;
+		}
+		tasksToDeploy.push(task);
+	}
+	return {
+		tasksToDeploy,
+		skippedTasks
+	};
+}
+function buildTaskTargetRegistrationItem(task, existingArtifacts, force) {
+	return {
+		taskId: task.taskId,
+		taskName: task.name,
+		storagePath: existingArtifacts[task.taskId]?.storagePath,
+		manifest: task.manifestData,
+		bundleSize: task.bundleSize,
+		bundleHash: task.bundleHash,
+		triggers: task.triggers,
+		skipVersionBump: !force && existingArtifacts[task.taskId]?.bundleHash === task.bundleHash
+	};
+}
+function mapTaskResultStatus(result) {
+	if (result.status === "failed") return {
+		name: result.name,
+		status: "failed",
+		error: result.error
+	};
+	if (result.status === "skipped") return {
+		name: result.name,
+		status: "skipped"
+	};
+	return {
+		name: result.name,
+		status: "deployed",
+		taskId: result.taskId
+	};
+}
+function releasePreparedTaskCallbackBundleCode(preparedTasks) {
+	for (const task of preparedTasks) for (const trigger of task.triggers) {
+		if (trigger.callbackBundle) trigger.callbackBundle.code = "";
+		if (trigger.transformCallbackBundle) trigger.transformCallbackBundle.code = "";
+	}
+}
+function finalizeTaskTargetResult(tasks, startedAt) {
+	return {
+		success: tasks.every((task) => task.status !== "failed"),
+		workflows: [],
+		agents: [],
+		tasks,
+		totalTime: Date.now() - startedAt
+	};
+}
+//#endregion
+export { deployTaskTargets as n, computeProjectSnapshotHash as t };

package/dist/task-target-deploy-runner.d.mts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+export { };

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

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+
+import { l as resolveAuthOptions } from "./dist-CUK7yBM0.mjs";
+import { n as findProjectRoot, t as assertWorkflowProjectRoot } from "./project-config-D1qsQlO7.mjs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+//#region src/lib/process-handoff.ts
+function replaceProcessOrSpawn(options) {
+	const execve = process.execve;
+	if (execve) {
+		execve(options.file, options.args, options.env);
+		throw new Error("process.execve returned unexpectedly.");
+	}
+	const result = spawnSync(options.file, options.args.slice(1), {
+		stdio: "inherit",
+		env: options.env
+	});
+	if (result.error) throw result.error;
+	process.exit(result.status ?? 1);
+}
+//#endregion
+//#region src/task-target-deploy-runner.ts
+const TASK_TARGET_DESCRIPTOR_PATH = path.join(".keystroke", "task-target-deploy", "descriptor.json");
+const TASK_TARGET_BUILD_DESCRIPTOR_PATH = path.join(".keystroke", "task-target-deploy", "build-descriptor.json");
+function parseArgs(argv) {
+	const options = {
+		targetFiles: [],
+		force: false,
+		dryRun: false,
+		disableSourcemaps: false,
+		stage: "deploy"
+	};
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		if (arg === "--path") {
+			options.path = argv[index + 1];
+			index += 1;
+		} else if (arg === "--target") {
+			const targetFile = argv[index + 1];
+			if (targetFile) options.targetFiles.push(targetFile);
+			index += 1;
+		} else if (arg === "--force") options.force = true;
+		else if (arg === "--dry-run") options.dryRun = true;
+		else if (arg === "--disable-sourcemaps") options.disableSourcemaps = true;
+		else if (arg === "--stage") {
+			const stage = argv[index + 1];
+			options.stage = stage === "deploy-only" ? "deploy-only" : stage === "prepare" ? "prepare" : "deploy";
+			index += 1;
+		} else if (arg === "--api-key") {
+			options.apiKey = argv[index + 1];
+			index += 1;
+		} else if (arg === "--base-url") {
+			options.baseUrl = argv[index + 1];
+			index += 1;
+		} else if (arg === "--org") {
+			options.org = argv[index + 1];
+			index += 1;
+		}
+	}
+	return options;
+}
+async function resolveProjectRoot(explicitPath) {
+	if (explicitPath) return path.resolve(explicitPath);
+	const discovered = await findProjectRoot(process.cwd());
+	if (!discovered) throw new Error("No keystroke.config.ts found. Run `keystroke init` or pass --path.");
+	return discovered;
+}
+function descriptorPath(projectRoot) {
+	return path.join(projectRoot, TASK_TARGET_DESCRIPTOR_PATH);
+}
+function buildDescriptorPath(projectRoot) {
+	return path.join(projectRoot, TASK_TARGET_BUILD_DESCRIPTOR_PATH);
+}
+async function writeDescriptor(projectRoot, descriptor) {
+	const filePath = descriptorPath(projectRoot);
+	await mkdir(path.dirname(filePath), { recursive: true });
+	await writeFile(filePath, `${JSON.stringify(descriptor)}\n`, "utf-8");
+}
+async function readDescriptor(projectRoot) {
+	return JSON.parse(await readFile(descriptorPath(projectRoot), "utf-8"));
+}
+async function writeBuildDescriptor(projectRoot, descriptor) {
+	const filePath = buildDescriptorPath(projectRoot);
+	await mkdir(path.dirname(filePath), { recursive: true });
+	await writeFile(filePath, `${JSON.stringify(descriptor)}\n`, "utf-8");
+}
+async function readBuildDescriptor(projectRoot) {
+	return JSON.parse(await readFile(buildDescriptorPath(projectRoot), "utf-8"));
+}
+function restartStage(options, projectRoot, stage) {
+	const runnerPath = process.argv[1];
+	if (!runnerPath) throw new Error("Unable to resolve task target deploy runner path.");
+	const args = [
+		process.execPath,
+		...process.execArgv,
+		runnerPath,
+		"--path",
+		projectRoot,
+		"--stage",
+		stage,
+		...options.dryRun ? ["--dry-run"] : [],
+		...options.force ? ["--force"] : [],
+		...options.disableSourcemaps ? ["--disable-sourcemaps"] : [],
+		...options.apiKey ? ["--api-key", options.apiKey] : [],
+		...options.baseUrl ? ["--base-url", options.baseUrl] : [],
+		...options.org ? ["--org", options.org] : [],
+		...options.targetFiles.flatMap((targetFile) => ["--target", targetFile])
+	];
+	replaceProcessOrSpawn({
+		file: process.execPath,
+		args,
+		env: { ...process.env }
+	});
+}
+async function runBuildPhase(options, projectRoot) {
+	const projectConfig = await assertWorkflowProjectRoot(projectRoot);
+	const { buildTaskTargetEntries } = await import("./task-target-build-CBeCKbu2.mjs");
+	await writeBuildDescriptor(projectRoot, {
+		projectRoot,
+		projectConfig,
+		builtTasks: await buildTaskTargetEntries({
+			projectRoot,
+			targetFiles: options.targetFiles,
+			disableSourcemaps: options.disableSourcemaps
+		})
+	});
+}
+async function runPreparePhase(projectRoot) {
+	const buildDescriptor = await readBuildDescriptor(projectRoot);
+	const { prepareTaskTargetBuiltTasks } = await import("./task-target-build-CBeCKbu2.mjs");
+	const prepareResult = await prepareTaskTargetBuiltTasks({
+		builtTasks: buildDescriptor.builtTasks,
+		projectRoot
+	});
+	if (prepareResult.failures.length > 0) throw new Error(prepareResult.failures.map((failure) => failure.error).join("\n"));
+	await writeDescriptor(projectRoot, {
+		projectRoot,
+		projectConfig: buildDescriptor.projectConfig,
+		preparedTasks: prepareResult.preparedTasks
+	});
+}
+async function resolveDeployAuthOptions(options) {
+	const resolved = await resolveAuthOptions({
+		apiKey: options.apiKey,
+		baseUrl: options.baseUrl
+	});
+	const apiKey = options.apiKey ?? resolved.apiKey ?? process.env.KEYSTROKE_API_KEY;
+	const baseUrl = options.baseUrl ?? resolved.baseUrl ?? process.env.SERVER_URL;
+	const organizationId = options.org ?? process.env.KEYSTROKE_ORG_ID ?? resolved.activeOrg?.organizationId;
+	if (!apiKey || !baseUrl) throw new Error("Not authenticated. Run `keystroke auth` or pass --api-key and --base-url.");
+	return {
+		apiKey,
+		baseUrl,
+		...organizationId ? { organizationId } : {}
+	};
+}
+async function runDeployPhase(options, projectRoot) {
+	const descriptor = await readDescriptor(projectRoot);
+	const { createDeployClient } = await import("./deploy-7Jjls436.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-C5X-USeR.mjs");
+	const result = await deployTaskTargets({
+		preparedTasks: descriptor.preparedTasks,
+		client,
+		organizationId: descriptor.projectConfig.organizationId,
+		projectId: descriptor.projectConfig.projectId,
+		projectRoot: descriptor.projectRoot,
+		force: options.force
+	});
+	if (result.success) return;
+	const errors = result.tasks.filter((task) => task.status === "failed").map((task) => `${task.name}: ${task.error ?? "Deployment failed"}`);
+	throw new Error(errors.length > 0 ? errors.join("\n") : "Task deployment failed");
+}
+async function run() {
+	const options = parseArgs(process.argv.slice(2));
+	if (options.targetFiles.length === 0) throw new Error("Task target deploy runner requires at least one --target file.");
+	const projectRoot = await resolveProjectRoot(options.path);
+	if (options.stage === "deploy-only") {
+		await runDeployPhase(options, projectRoot);
+		return;
+	}
+	if (options.stage === "prepare") {
+		await runPreparePhase(projectRoot);
+		if (options.dryRun) {
+			process.stdout.write("Dry run complete. Deployment skipped.\n");
+			return;
+		}
+		restartStage(options, projectRoot, "deploy-only");
+	}
+	await runBuildPhase(options, projectRoot);
+	restartStage(options, projectRoot, "prepare");
+}
+run().catch((error) => {
+	const message = error instanceof Error ? error.message : String(error);
+	process.stderr.write(`${message}\n`);
+	process.exitCode = 1;
+});
+//#endregion
+export {};