@keystrokehq/cli 0.0.1

package/dist/current-deployment-workflow-poHt27i3.mjs

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+import { E as WorkflowResolutionError, d as getApiErrorCode, f as getHttpStatus, t as ui } from "./keystroke.mjs";
+import { t as assertWorkflowProjectRoot } from "./project-config-D1qsQlO7.mjs";
+import { a as readManifestsFromOutDir } from "./dist-BkJUoBiG.mjs";
+import { t as requireWorkflowsDir } from "./resolve-project-DDJ29sCF.mjs";
+import { t as createSpinnerProgress } from "./spinner-progress-DMVwgqO9.mjs";
+import { a as runWorkflowBuild, n as renderBuildFailure } from "./workflow-build-DBQaBfnn.mjs";
+//#region src/commands/workflows/_shared/current-deployment-workflow.ts
+/**
+* Lightweight resolution: gets projectId from keystroke.config.ts and authoredWorkflowId
+* from cached manifests without triggering a build. Falls back to a full build
+* only if the cached manifest is unavailable and the ref isn't already an authored ID.
+*/
+async function resolveProjectContext(workflowRef, explicitPath, options) {
+	const workflowsDir = await requireWorkflowsDir(explicitPath);
+	const projectConfig = await assertWorkflowProjectRoot(workflowsDir);
+	const cachedId = (await readManifestsFromOutDir(workflowsDir, workflowRef))[0]?.manifest.id;
+	if (typeof cachedId === "string" && cachedId.length > 0) return {
+		workflowsDir,
+		organizationId: projectConfig.organizationId,
+		projectId: projectConfig.projectId,
+		authoredWorkflowId: cachedId
+	};
+	if (workflowRef.startsWith("wf_")) return {
+		workflowsDir,
+		organizationId: projectConfig.organizationId,
+		projectId: projectConfig.projectId,
+		authoredWorkflowId: workflowRef
+	};
+	const resolved = await resolveLocalWorkflowManifest(workflowRef, explicitPath, options);
+	return {
+		workflowsDir: resolved.workflowsDir,
+		organizationId: resolved.organizationId,
+		projectId: resolved.projectId,
+		authoredWorkflowId: resolved.authoredWorkflowId
+	};
+}
+async function resolveLocalWorkflowManifest(workflowRef, explicitPath, options) {
+	const workflowsDir = await requireWorkflowsDir(explicitPath);
+	let results = await readManifestsFromOutDir(workflowsDir, workflowRef);
+	if (results.length === 0) {
+		const spinner = !options?.jsonMode ? createSpinnerProgress("[resolve]") : void 0;
+		spinner?.start(`Building "${workflowRef}" to resolve manifest...`);
+		try {
+			await runWorkflowBuild({
+				workflowsDir,
+				workflowRef,
+				verbose: false,
+				force: false
+			});
+			spinner?.stop();
+		} catch (error) {
+			spinner?.stop();
+			renderBuildFailure(error);
+			throw new WorkflowResolutionError(`Build failed for "${workflowRef}"`);
+		}
+		results = await readManifestsFromOutDir(workflowsDir, workflowRef);
+	}
+	const found = results[0];
+	if (!found) {
+		ui.error(`Workflow "${workflowRef}" not found.`);
+		throw new WorkflowResolutionError(`Workflow "${workflowRef}" not found.`);
+	}
+	const authoredWorkflowId = typeof found.manifest.id === "string" && found.manifest.id.length > 0 ? found.manifest.id : null;
+	if (!authoredWorkflowId) {
+		ui.error(`Workflow "${workflowRef}" is missing an authored workflow ID.`);
+		throw new WorkflowResolutionError(`Workflow "${workflowRef}" is missing an authored workflow ID.`);
+	}
+	const projectConfig = await assertWorkflowProjectRoot(workflowsDir);
+	return {
+		workflowsDir,
+		organizationId: projectConfig.organizationId,
+		projectId: projectConfig.projectId,
+		authoredWorkflowId,
+		manifest: found.manifest
+	};
+}
+async function lookupCurrentDeploymentWorkflow(client, params) {
+	try {
+		return {
+			status: "found",
+			workflow: (await client.projects.getCurrentDeploymentWorkflow(params.projectId, params.authoredWorkflowId)).workflow
+		};
+	} catch (error) {
+		if (getHttpStatus(error) !== 404) throw error;
+		const errorCode = await getApiErrorCode(error);
+		if (errorCode === "no_current_deployment") return { status: "missingCurrentDeployment" };
+		if (errorCode === "workflow_not_in_deployment") return { status: "missingWorkflow" };
+		throw error;
+	}
+}
+//#endregion
+export { resolveLocalWorkflowManifest as n, resolveProjectContext as r, lookupCurrentDeploymentWorkflow as t };

package/dist/current.handler-B8zKzfPp.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+import { t as ui } from "./keystroke.mjs";
+import { i as requireClient } from "./context-T7HZuB97.mjs";
+//#region src/commands/org/current.handler.ts
+async function handleOrgCurrent(_options, ctx) {
+	if (!ctx.organizationId) {
+		ui.warn("No organization set. Use `keystroke org switch` or `--org` to select one.");
+		return;
+	}
+	const { user } = await requireClient(ctx).users.getMe();
+	const currentOrg = user.organizations?.find((o) => o.id === ctx.organizationId);
+	if (currentOrg) {
+		ui.text(`Current organization: ${currentOrg.name}`);
+		if (ctx.orgSource) ui.hint(`Source: ${ctx.orgSource}`);
+	} else ui.text(`Current organization ID: ${ctx.organizationId}`);
+	const storedOrgCount = ctx.storedCredentials?.orgs.length ?? 0;
+	if (storedOrgCount > 1) ui.hint(`${storedOrgCount} organizations with stored credentials. Use \`keystroke org switch\` to change.`);
+}
+//#endregion
+export { handleOrgCurrent };

package/dist/delete.handler-bAu1iXVQ.mjs

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+import { D as throwReportedCliExit, h as toErrorMessage, t as ui } from "./keystroke.mjs";
+import { i as requireClient } from "./context-T7HZuB97.mjs";
+//#region src/commands/api-keys/delete.handler.ts
+async function handleApiKeysDelete(options, ctx) {
+	const client = requireClient(ctx);
+	try {
+		await client.apiKeys.remove(options.apiKeyId);
+		ui.success("API key deleted.");
+	} catch (error) {
+		ui.error(`Failed to delete API key: ${toErrorMessage(error)}`);
+		throwReportedCliExit(`Failed to delete API key: ${toErrorMessage(error)}`, { cause: error });
+	}
+}
+//#endregion
+export { handleApiKeysDelete };

package/dist/deploy-7Jjls436.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+import { a as createKyInstance, n as auth, r as bundles, s as getClientEnv, t as projects } from "./projects-CHkRE9rS.mjs";
+//#region ../../packages/workflow-sdk/src/deploy.ts
+function createDeployClient(config = {}) {
+	const env = getClientEnv();
+	const baseUrl = config.baseUrl ?? env.SERVER_URL;
+	const apiKey = config.apiKey ?? env.KEYSTROKE_API_KEY;
+	const organizationId = config.organizationId ?? env.KEYSTROKE_ORG_ID;
+	if (!baseUrl) throw new Error("baseUrl is required (pass in config or set SERVER_URL)");
+	if (!apiKey) throw new Error("Keystroke API Key is required (pass apiKey or set KEYSTROKE_API_KEY)");
+	const v1 = createKyInstance({
+		prefixUrl: baseUrl,
+		apiKey,
+		organizationId
+	}).extend((options) => ({ prefixUrl: `${options.prefixUrl}/api/v1` }));
+	return {
+		public: {
+			auth: { validate: auth(v1).validate },
+			projects: projects(v1)
+		},
+		bundles: { getHashes: bundles(v1).getHashes }
+	};
+}
+//#endregion
+export { createDeployClient };

package/dist/deploy-BOPIpRWm.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+import { t as createTypedCommand } from "./commander-DfTVqQ-3.mjs";
+import { z } from "zod";
+//#region src/commands/deploy/deploy.command.ts
+/**
+* Deploy command options schema
+*/
+const DeployOptionsSchema = z.object({
+	path: z.string().optional().describe("Path to the workflow directory"),
+	dryRun: z.boolean().default(false).describe("Run without making changes"),
+	diff: z.boolean().default(false).describe("Show current deployment diff before deploying"),
+	verbose: z.boolean().default(false).describe("Show detailed output"),
+	force: z.boolean().default(false).describe("Deploy even if bundle unchanged"),
+	target: z.array(z.string()).default([]).describe("Deploy deployable exports from a target source file; repeat for multiple files"),
+	incrementalBuild: z.boolean().default(false).describe("Use workflow build cache when combined with --force (still forces upload/registration; omit for a full clean rebuild)"),
+	disableSourcemaps: z.boolean().default(false).describe("Disable sourcemap generation")
+});
+/**
+* Commander option configuration for deploy command
+*/
+const DEPLOY_OPTIONS_CONFIG = {
+	path: {
+		flag: "--path <path>",
+		description: "Path to project root (directory containing keystroke.config.ts); auto-discovered from CWD if omitted"
+	},
+	dryRun: {
+		flag: "--dry-run",
+		description: "Build and validate only, do not upload"
+	},
+	diff: {
+		flag: "--diff",
+		description: "Show current deployment diff before deploying"
+	},
+	verbose: {
+		flag: "--verbose",
+		description: "Show detailed deployment logs"
+	},
+	force: {
+		flag: "--force",
+		description: "Deploy even if bundle unchanged (will not bump version)"
+	},
+	target: {
+		flag: "--target <file>",
+		description: "Deploy deployable exports from a target source file; repeat for multiple files",
+		collect: true
+	},
+	incrementalBuild: {
+		flag: "--incremental-build",
+		description: "With --force, skip busting the local workflow build cache (still forces deploy/upload)"
+	},
+	disableSourcemaps: {
+		flag: "--disable-sourcemaps",
+		description: "Disable sourcemap generation for deployment bundles"
+	}
+};
+/**
+* Creates the deploy command
+*/
+function createDeployCommand() {
+	const cmd = createTypedCommand({
+		name: "deploy",
+		description: "Deploy the current project snapshot to Keystroke",
+		schema: DeployOptionsSchema,
+		optionsConfig: DEPLOY_OPTIONS_CONFIG,
+		contextMode: "auth",
+		loadHandler: async () => (await import("./deploy.handler-BAzgiNhd.mjs")).handleDeploy
+	});
+	cmd.enablePositionalOptions();
+	cmd.passThroughOptions();
+	return cmd;
+}
+//#endregion
+export { createDeployCommand };

package/dist/deploy-progress-BmGUNFKg.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+import { t as ui } from "./keystroke.mjs";
+import { t as createSpinnerProgress } from "./spinner-progress-DMVwgqO9.mjs";
+//#region src/lib/deploy-progress.ts
+function renderItemFailure(event, kind, spinner) {
+	if (event.result === "failure") spinner.fail(`${kind} failed (${event.name})`, void 0, event.error);
+}
+function createDeployProgress() {
+	const spinner = createSpinnerProgress("[deploy]");
+	let completedSuccessfully = false;
+	function handleEvent(event) {
+		if (event.phase === "prepare") {
+			if (event.status === "warning") {
+				ui.warn(event.warning);
+				return;
+			}
+			return;
+		}
+		if (event.phase === "filter") return;
+		if (event.phase === "upload-workflows" || event.phase === "upload-agents" || event.phase === "upload-tasks") {
+			if (event.status === "item") {
+				renderItemFailure(event, event.phase === "upload-workflows" ? "Workflow upload" : event.phase === "upload-agents" ? "Agent upload" : "Task upload", spinner);
+				return;
+			}
+			if (event.status === "complete" && event.failed > 0) {
+				const kind = event.phase === "upload-workflows" ? "workflow" : event.phase === "upload-agents" ? "agent" : "task";
+				spinner.fail(`Upload failed (${event.succeeded} ${kind}(s) succeeded, ${event.failed} failed)`, event.elapsedMs);
+			}
+			return;
+		}
+		if (event.phase === "register-workflows" || event.phase === "register-agents" || event.phase === "register-tasks") {
+			if (event.status === "item") {
+				renderItemFailure(event, event.phase === "register-workflows" ? "Workflow registration" : event.phase === "register-agents" ? "Agent registration" : "Task registration", spinner);
+				return;
+			}
+			if (event.status === "complete" && event.failed > 0) {
+				const kind = event.phase === "register-workflows" ? "workflow" : event.phase === "register-agents" ? "agent" : "task";
+				spinner.fail(`Registration failed (${event.succeeded} ${kind}(s) succeeded, ${event.failed} failed)`, event.elapsedMs);
+			}
+			return;
+		}
+		if (event.phase === "hash-check") return;
+		if (event.phase === "sync-file-metadata") return;
+		if (event.phase === "complete") {
+			if (event.success) {
+				const parts = [];
+				if (event.workflowsTotal > 0) parts.push(`${event.workflowsTotal} workflow(s)`);
+				if (event.agentsTotal > 0) parts.push(`${event.agentsTotal} agent(s)`);
+				if (event.tasksTotal > 0) parts.push(`${event.tasksTotal} task(s)`);
+				spinner.complete(`Deployed ${parts.join(" and ")}`, event.elapsedMs);
+				completedSuccessfully = true;
+				return;
+			}
+			spinner.fail("Deployment completed with failures", event.elapsedMs);
+			return;
+		}
+		throw new Error(`Unhandled deploy progress event: ${JSON.stringify(event)}`);
+	}
+	function stop() {
+		if (!completedSuccessfully) spinner.stop();
+	}
+	spinner.start("Deploying...");
+	return {
+		handleEvent,
+		stop
+	};
+}
+//#endregion
+export { createDeployProgress as t };

package/dist/deploy.handler-BAzgiNhd.mjs

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+
+import { C as CliExitError, i as logger, o as ANSI, s as style, t as ui } from "./keystroke.mjs";
+import { d as trackProject } from "./dist-CUK7yBM0.mjs";
+import { t as assertWorkflowProjectRoot } from "./project-config-D1qsQlO7.mjs";
+import { i as readAgentManifestsFromOutDir, o as readWorkflowsFromDisk } from "./dist-BkJUoBiG.mjs";
+import { t as requireWorkflowsDir } from "./resolve-project-DDJ29sCF.mjs";
+import { n as renderBuildFailure, r as renderBuildHeader } from "./workflow-build-DBQaBfnn.mjs";
+import { r as isLocalMode } from "./env-91KwMKov.mjs";
+import { r as requireAuthOptions, t as assertProjectConfigMatchesAuthenticatedOrg } from "./context-T7HZuB97.mjs";
+import { t as createBuildProgress } from "./build-progress-DgYKb4hB.mjs";
+import { t as createDeployProgress } from "./deploy-progress-BmGUNFKg.mjs";
+import { t as withErrorBoundary } from "./error-boundary-VL-JLfIa.mjs";
+import { t as lookupCurrentDeploymentWorkflow } from "./current-deployment-workflow-poHt27i3.mjs";
+import { t as computeWorkflowDiff } from "./diff-utils-NEfcjqxt.mjs";
+import { access } from "node:fs/promises";
+import path from "node:path";
+//#region src/commands/deploy/deploy-diff.ts
+const deployDiffDependencies = {
+	readWorkflowsFromDisk,
+	readAgentManifestsFromOutDir
+};
+async function computeDeployDiff(params) {
+	const workflows = await deployDiffDependencies.readWorkflowsFromDisk(params.outDir);
+	const workflowDiffs = [];
+	let missingCurrentDeployment = false;
+	for (const workflow of workflows) {
+		let deployed = null;
+		if (!missingCurrentDeployment) {
+			const lookup = await lookupCurrentDeploymentWorkflow(params.client, {
+				projectId: params.projectId,
+				authoredWorkflowId: workflow.manifestData.id
+			});
+			if (lookup.status === "found") deployed = lookup.workflow.manifest;
+			else if (lookup.status === "missingCurrentDeployment") missingCurrentDeployment = true;
+		}
+		workflowDiffs.push(computeWorkflowDiff(workflow.manifestData, deployed, {
+			workflowName: workflow.name,
+			deployedVersion: null
+		}));
+	}
+	return {
+		workflows: workflowDiffs,
+		agents: (await deployDiffDependencies.readAgentManifestsFromOutDir(params.workflowsDir)).map(({ manifest }) => ({
+			authoredAgentId: manifest.authoredAgentId,
+			agentName: manifest.agentName,
+			workflowTools: (manifest.tools ?? []).filter((tool) => tool.sourceKind === "workflow")
+		})),
+		hasChanges: workflowDiffs.some((diff) => diff.hasChanges)
+	};
+}
+function renderDeployDiff(diff) {
+	ui.header("Deploy diff");
+	ui.br();
+	ui.text(style("Workflows", ANSI.bold));
+	if (diff.workflows.length === 0) ui.text(style("  (none)", ANSI.dim));
+	else for (const workflow of diff.workflows) {
+		const marker = workflow.notYetDeployed ? "+" : workflow.hasChanges ? "~" : " ";
+		const color = workflow.notYetDeployed ? ANSI.green : workflow.hasChanges ? ANSI.yellow : ANSI.dim;
+		ui.text(style(`  ${marker} ${workflow.workflowName}`, color));
+	}
+	ui.br();
+	ui.text(style("Agent Workflow Tools", ANSI.bold));
+	if (diff.agents.length === 0) ui.text(style("  (none)", ANSI.dim));
+	else for (const agent of diff.agents) {
+		ui.text(`  ${agent.authoredAgentId} (${agent.agentName})`);
+		if (agent.workflowTools.length === 0) {
+			ui.text(style("    (no workflow tools)", ANSI.dim));
+			continue;
+		}
+		for (const tool of agent.workflowTools) {
+			const deployment = tool.deploymentId ? ` deployment=${tool.deploymentId}` : "";
+			const invocation = tool.invocation ? ` invocation=${tool.invocation}` : "";
+			ui.text(`    ${tool.toolName}: workflow=${tool.authoredWorkflowId ?? "unknown"}${deployment}${invocation}`);
+		}
+	}
+	ui.br();
+	if (diff.hasChanges) ui.warn("Workflow changes detected against the current deployment.");
+	else ui.success("No workflow changes detected.");
+}
+//#endregion
+//#region src/commands/deploy/deploy-targets.ts
+var DeployTargetError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "DeployTargetError";
+	}
+};
+function getDeployMode(targets) {
+	return targets.some((target) => target.trim().length > 0) ? "targets" : "project";
+}
+function classifyDeployTargetFile(filePath) {
+	if (filePath.endsWith(".workflow.ts")) return "workflow";
+	if (filePath.endsWith(".agent.ts")) return "agent";
+	if (filePath.endsWith(".task.ts")) return "task";
+	return "unknown";
+}
+async function resolveDeployTargetFiles(projectRoot, targets) {
+	const resolvedTargets = [];
+	for (const inputPath of targets) {
+		const trimmedInput = inputPath.trim();
+		if (trimmedInput.length === 0) continue;
+		const absolutePath = path.normalize(path.isAbsolute(trimmedInput) ? trimmedInput : path.resolve(projectRoot, trimmedInput));
+		const projectRelativePath = path.relative(projectRoot, absolutePath);
+		if (projectRelativePath.startsWith("..") || path.isAbsolute(projectRelativePath)) throw new DeployTargetError(`Target file "${inputPath}" must be inside project root ${projectRoot}.`);
+		await access(absolutePath).catch(() => {
+			throw new DeployTargetError(`Target file "${inputPath}" was not found.`);
+		});
+		const kind = classifyDeployTargetFile(absolutePath);
+		if (kind === "unknown") throw new DeployTargetError(`Target file "${inputPath}" is not deployable. Expected a .workflow.ts, .agent.ts, or .task.ts file.`);
+		resolvedTargets.push({
+			kind,
+			inputPath,
+			absolutePath,
+			projectRelativePath
+		});
+	}
+	return resolvedTargets;
+}
+function groupDeployTargetsByKind(targets) {
+	const grouped = {
+		workflows: [],
+		agents: [],
+		tasks: []
+	};
+	for (const target of targets) switch (target.kind) {
+		case "workflow":
+			grouped.workflows.push(target);
+			break;
+		case "agent":
+			grouped.agents.push(target);
+			break;
+		case "task":
+			grouped.tasks.push(target);
+			break;
+		default: {
+			const exhaustive = target.kind;
+			throw new DeployTargetError(`Unsupported target kind: ${exhaustive}`);
+		}
+	}
+	return grouped;
+}
+function buildDeployArtifactFilter(result, deployMode) {
+	if (deployMode === "project") return;
+	return {
+		workflows: result.artifacts.map((artifact) => artifact.manifest.name),
+		agents: result.agentArtifacts.map((artifact) => artifact.agent.agentId),
+		tasks: result.taskArtifacts.map((artifact) => artifact.task.taskId)
+	};
+}
+//#endregion
+//#region src/commands/deploy/deploy.handler.ts
+const deployHandlerDependencies = {
+	deployFromDir: void 0,
+	buildTaskTargets: void 0,
+	createDeployClient: void 0,
+	deployTaskTargets: void 0
+};
+async function handleDeploy(options, ctx) {
+	return withErrorBoundary("Deployment", async () => {
+		const workflowsDir = await requireWorkflowsDir(options.path);
+		const projectConfig = await assertWorkflowProjectRoot(workflowsDir);
+		const deployMode = getDeployMode(options.target);
+		const groupedTargets = groupDeployTargetsByKind(deployMode === "targets" ? await resolveDeployTargetFiles(workflowsDir, options.target) : []);
+		const artifactKinds = deployMode === "targets" ? [
+			...groupedTargets.workflows.length > 0 ? ["workflow"] : [],
+			...groupedTargets.agents.length > 0 ? ["agent"] : [],
+			...groupedTargets.tasks.length > 0 ? ["task"] : []
+		] : [
+			"workflow",
+			"agent",
+			"task"
+		];
+		trackProject(workflowsDir);
+		const forceBuild = options.force && !options.incrementalBuild;
+		logger.info("Starting deployment", {
+			workflowsDir,
+			dryRun: options.dryRun,
+			forceBuild,
+			targets: options.target
+		});
+		if (deployMode === "targets" && groupedTargets.tasks.length > 0 && groupedTargets.workflows.length === 0 && groupedTargets.agents.length === 0) {
+			await handleTaskTargetDeploy({
+				workflowsDir,
+				projectConfig,
+				options,
+				ctx,
+				targetFiles: options.target
+			});
+			return;
+		}
+		let client;
+		if (!options.dryRun || options.diff) {
+			client = await createFullDeployClient(ctx);
+			await assertProjectConfigMatchesAuthenticatedOrg(client, projectConfig);
+		}
+		renderBuildHeader(void 0);
+		const buildProgress = createBuildProgress("project");
+		let outDir;
+		let artifactFilter;
+		try {
+			const { runWorkflowBuild } = await import("./workflow-build-DBQaBfnn.mjs").then((n) => n.o);
+			const buildOutcome = await runWorkflowBuild({
+				workflowsDir,
+				verbose: options.verbose,
+				force: forceBuild,
+				targetFiles: options.target,
+				releaseBundleMemory: true,
+				...options.disableSourcemaps ? { sourceMaps: false } : {},
+				onProgressEvent: (event) => buildProgress.handleEvent(event)
+			});
+			outDir = buildOutcome.outDir;
+			artifactFilter = buildDeployArtifactFilter(buildOutcome.result, deployMode);
+		} catch (error) {
+			renderBuildFailure(error);
+			throw new CliExitError("Build failed");
+		} finally {
+			buildProgress.stop();
+		}
+		if (options.diff) {
+			if (!client) throw new CliExitError("Deployment client was not initialized.");
+			renderDeployDiff(await computeDeployDiff({
+				outDir,
+				workflowsDir,
+				projectId: projectConfig.projectId,
+				client
+			}));
+		}
+		if (options.dryRun) {
+			ui.success("Dry run complete. Deployment skipped.");
+			return;
+		}
+		if (!client) throw new CliExitError("Deployment client was not initialized.");
+		const progress = createDeployProgress();
+		let result;
+		try {
+			result = await (deployHandlerDependencies.deployFromDir ?? (await import("./dist-BkJUoBiG.mjs").then((n) => n.r)).deployFromDir)({
+				outDir,
+				workflowsDir,
+				client,
+				isLocalMode: isLocalMode(),
+				force: options.force,
+				deploymentScope: deployMode === "targets" ? "targets" : "project",
+				...deployMode === "targets" ? {
+					artifactFilter,
+					artifactKinds
+				} : {},
+				onDeployProgressEvent: (event) => progress.handleEvent(event)
+			});
+		} finally {
+			progress.stop();
+		}
+		await new Promise((resolve) => setImmediate(resolve));
+		if (result.success) {
+			renderSuccessSummary(result);
+			return;
+		}
+		renderFailureSummary(result);
+		throw new CliExitError("Deployment failed");
+	}, { json: ctx.jsonMode });
+}
+async function handleTaskTargetDeploy(options) {
+	renderBuildHeader(void 0);
+	const buildResult = await (deployHandlerDependencies.buildTaskTargets ?? (await import("./task-target-build-CBeCKbu2.mjs")).buildTaskTargets)({
+		projectRoot: options.workflowsDir,
+		targetFiles: options.targetFiles,
+		disableSourcemaps: options.options.disableSourcemaps
+	});
+	if (buildResult.failures.length > 0) {
+		for (const failure of buildResult.failures) ui.error(failure.error);
+		throw new CliExitError("Build failed");
+	}
+	if (options.options.dryRun) {
+		ui.success("Dry run complete. Deployment skipped.");
+		return;
+	}
+	const client = await createTaskDeployClient(options.ctx);
+	await assertProjectConfigMatchesAuthenticatedOrg(client, options.projectConfig);
+	const progress = createDeployProgress();
+	let result;
+	try {
+		result = await (deployHandlerDependencies.deployTaskTargets ?? (await import("./task-target-deploy-C5X-USeR.mjs")).deployTaskTargets)({
+			preparedTasks: buildResult.preparedTasks,
+			client,
+			organizationId: options.projectConfig.organizationId,
+			projectId: options.projectConfig.projectId,
+			projectRoot: options.workflowsDir,
+			force: options.options.force,
+			onDeployProgressEvent: (event) => progress.handleEvent(event)
+		});
+	} finally {
+		progress.stop();
+	}
+	await new Promise((resolve) => setImmediate(resolve));
+	if (result.success) {
+		renderSuccessSummary(result);
+		return;
+	}
+	renderFailureSummary(result);
+	throw new CliExitError("Deployment failed");
+}
+async function createFullDeployClient(ctx) {
+	const authOptions = requireAuthOptions(ctx);
+	const { createClient } = await import("./src-eHwu-Gfw.mjs");
+	return createClient({
+		...authOptions,
+		onRequest: (info) => logger.debug(`-> ${info.method} ${info.url}`, {
+			headers: info.headers,
+			body: info.body
+		}),
+		onResponse: (info) => logger.debug(`<- ${info.status} ${info.method} ${info.url} (${info.durationMs}ms)`, {
+			headers: info.headers,
+			body: info.body
+		})
+	});
+}
+async function createTaskDeployClient(ctx) {
+	const authOptions = requireAuthOptions(ctx);
+	return (deployHandlerDependencies.createDeployClient ?? (await import("./deploy-7Jjls436.mjs")).createDeployClient)(authOptions);
+}
+function renderSuccessSummary(result) {
+	const tasks = result.tasks || [];
+	if (result.workflows.length === 0 && result.agents.length === 0 && tasks.length === 0) {
+		ui.hint("Nothing to deploy.");
+		return;
+	}
+	const deployedWorkflows = result.workflows.filter((w) => w.status === "deployed");
+	const deployedAgents = result.agents.filter((a) => a.status === "deployed");
+	const deployedTasks = tasks.filter((t) => t.status === "deployed");
+	const skippedWorkflows = result.workflows.filter((w) => w.status === "skipped");
+	const skippedAgents = result.agents.filter((a) => a.status === "skipped");
+	const skippedTasks = tasks.filter((t) => t.status === "skipped");
+	if (deployedWorkflows.length === 0 && deployedAgents.length === 0 && deployedTasks.length === 0) {
+		if (skippedWorkflows.length > 0 || skippedAgents.length > 0 || skippedTasks.length > 0) ui.success("All workflows, agents, and tasks are up to date.");
+		return;
+	}
+}
+function renderFailureSummary(result) {
+	const tasks = result.tasks || [];
+	const failedWorkflows = result.workflows.filter((wf) => wf.status === "failed");
+	const failedAgents = result.agents.filter((agent) => agent.status === "failed");
+	const failedTasks = tasks.filter((task) => task.status === "failed");
+	ui.error("Deployment failed for some artifacts:");
+	const allErrors = [
+		...failedWorkflows.map((wf) => ({
+			name: wf.name,
+			kind: "workflow",
+			error: wf.error
+		})),
+		...failedAgents.map((a) => ({
+			name: a.name,
+			kind: "agent",
+			error: a.error
+		})),
+		...failedTasks.map((t) => ({
+			name: t.name,
+			kind: "task",
+			error: t.error
+		}))
+	];
+	const uniqueErrors = [...new Set(allErrors.map((e) => e.error))];
+	if (uniqueErrors.length === 1 && allErrors.length > 1 && allErrors.length > 3) ui.hint(`- ${failedWorkflows.length} workflow(s), ${failedAgents.length} agent(s), ${failedTasks.length} task(s): ${uniqueErrors[0]}`);
+	else {
+		for (const wf of failedWorkflows) ui.hint(`- workflow ${wf.name}: ${wf.error}`);
+		for (const agent of failedAgents) ui.hint(`- agent ${agent.name}: ${agent.error}`);
+		for (const task of failedTasks) ui.hint(`- task ${task.name}: ${task.error}`);
+	}
+}
+//#endregion
+export { handleDeploy };