@keystrokehq/cli 0.0.1

package/dist/normalize-path-CojS-CgQ-DLCOvnD1.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+import { r as RelativeFilePathSchema } from "./file-metadata-D1vm-XY2.mjs";
+import path from "node:path";
+//#region ../../packages/workflow-builder/dist/normalize-path-CojS-CgQ.mjs
+function normalizeRelativeFilePath(relativePath) {
+	const normalizedPath = relativePath.replaceAll("\\", "/");
+	return RelativeFilePathSchema.parse(normalizedPath);
+}
+/** Parse a string as a `RelativeFilePath`, throwing if it's not a valid normalized relative path. */
+function parseRelativeFilePath(raw) {
+	return RelativeFilePathSchema.parse(raw);
+}
+function toRelativeFilePath(projectRoot, filePath) {
+	const resolvedProjectRoot = path.resolve(projectRoot);
+	const resolvedFilePath = path.resolve(filePath);
+	return normalizeRelativeFilePath(path.relative(resolvedProjectRoot, resolvedFilePath));
+}
+//#endregion
+export { parseRelativeFilePath as n, toRelativeFilePath as r, normalizeRelativeFilePath as t };

package/dist/options-CeaTcFxP.mjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+import { z } from "zod";
+//#region src/commands/workflows/_shared/options.ts
+/**
+* Options schema for `workflows try-deploy` (build, upload, and run on server).
+*
+* Resolution order for workflow ref: authored workflow id (preferred) then name. If multiple workflows share a
+* name, all are run sequentially. Use workflow id for exact targeting.
+*/
+const WorkflowsRunOptionsSchema = z.object({
+	/** Authored workflow id (preferred) or workflow name. */
+	workflow: z.string(),
+	input: z.string().optional(),
+	inputFile: z.string().optional(),
+	path: z.string().optional(),
+	verbose: z.boolean().default(false),
+	timeout: z.coerce.number().int().default(120)
+});
+const RUN_OPTIONS_CONFIG = {
+	input: {
+		flag: "--input <json>",
+		description: "Workflow input as inline JSON string"
+	},
+	inputFile: {
+		flag: "--input-file <path>",
+		description: "Path to a JSON file containing workflow input"
+	},
+	path: {
+		flag: "--path <dir>",
+		description: "Path to project root (directory containing keystroke.config.ts); auto-discovered from CWD if omitted"
+	},
+	verbose: {
+		flag: "--verbose",
+		description: "Show detailed build and execution logs"
+	},
+	timeout: {
+		flag: "--timeout <seconds>",
+		description: "Max seconds to wait for workflow completion (default: 120)"
+	}
+};
+//#endregion
+export { WorkflowsRunOptionsSchema as n, RUN_OPTIONS_CONFIG as t };

package/dist/org-xLzBtt2_.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+import { t as createTypedCommand } from "./commander-DfTVqQ-3.mjs";
+import { z } from "zod";
+//#region src/commands/org/org.command.ts
+const OrgOptionsSchema = z.object({});
+const ORG_OPTIONS_CONFIG = {};
+function createOrgCommand() {
+	return createTypedCommand({
+		name: "org",
+		description: "Manage organization context",
+		schema: OrgOptionsSchema,
+		optionsConfig: ORG_OPTIONS_CONFIG,
+		loadHandler: async () => (await import("./list.handler-CWF_Dj15.mjs")).handleOrgList,
+		subcommands: [
+			createTypedCommand({
+				name: "list",
+				description: "List your organizations",
+				schema: OrgOptionsSchema,
+				optionsConfig: ORG_OPTIONS_CONFIG,
+				loadHandler: async () => (await import("./list.handler-CWF_Dj15.mjs")).handleOrgList
+			}),
+			createTypedCommand({
+				name: "current",
+				description: "Show the current organization",
+				schema: OrgOptionsSchema,
+				optionsConfig: ORG_OPTIONS_CONFIG,
+				loadHandler: async () => (await import("./current.handler-B8zKzfPp.mjs")).handleOrgCurrent
+			}),
+			createTypedCommand({
+				name: "switch",
+				description: "Switch to a different organization",
+				schema: OrgOptionsSchema,
+				optionsConfig: ORG_OPTIONS_CONFIG,
+				loadHandler: async () => (await import("./switch.handler-D_9213Vf.mjs")).handleOrgSwitch
+			})
+		]
+	});
+}
+//#endregion
+export { createOrgCommand };

package/dist/output-DM4b7KgY.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+import { D as throwReportedCliExit } from "./keystroke.mjs";
+import { z } from "zod";
+//#region src/lib/output.ts
+/**
+* Shared Zod schema for the `--json` flag.
+* Use `.extend()` or spread `.shape` to add to command schemas.
+*
+* The field is `optional()` (no default) so we can distinguish:
+* - `true`      → explicit `--json`
+* - `false`     → explicit `--no-json`
+* - `undefined` → not specified → auto-detect via TTY
+*/
+const JsonOptionSchema = z.object({ json: z.boolean().optional() });
+/** Shared option config entry for --json. Spread into command option configs. */
+const JSON_OPTION_CONFIG = { json: {
+	flag: "--json",
+	description: "Output machine-readable JSON"
+} };
+/**
+* Determines whether the current command should output JSON.
+*
+* - `--json`    → always true
+* - `--no-json` → always false
+* - (omitted)   → true when stdout is NOT a TTY (piped / captured)
+*/
+function isJsonMode(options) {
+	if (options.json === true) return true;
+	if (options.json === false) return false;
+	return !process.stdout.isTTY;
+}
+/**
+* Writes structured JSON to stdout.
+*
+* - With `pagination`: wraps data as `{ items: data, pagination: { ...meta, hasMore } }`
+* - Without pagination: writes `data` directly (caller shapes the object)
+*/
+function writeJson(data, pagination) {
+	if (pagination) {
+		const output = {
+			items: data,
+			pagination: {
+				limit: pagination.limit,
+				offset: pagination.offset,
+				total: pagination.total,
+				hasMore: pagination.offset + pagination.limit < pagination.total
+			}
+		};
+		process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+	} else process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
+/**
+* Writes a structured JSON error to stdout and stops command execution.
+*
+* Output shape: `{ error: string, code?: string, hint?: string }`
+* Agents detect errors by checking for the `error` key in the response.
+*
+* `cause` is forwarded onto the thrown `CliExitError` so the underlying error
+* is preserved for logging and telemetry; it is deliberately not written to
+* stdout (agents should parse only the documented `{ error, code?, hint? }`
+* shape).
+*/
+function writeJsonError(message, opts) {
+	const output = { error: message };
+	if (opts?.code) output.code = opts.code;
+	if (opts?.hint) output.hint = opts.hint;
+	process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+	throwReportedCliExit(message, opts?.cause !== void 0 ? { cause: opts.cause } : {});
+}
+//#endregion
+export { writeJsonError as a, writeJson as i, JsonOptionSchema as n, isJsonMode as r, JSON_OPTION_CONFIG as t };

package/dist/oxc-B3KI3rf_-n9d1hKNq.mjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+import { parseSync, visitorKeys } from "oxc-parser";
+//#region ../../packages/workflow-builder/dist/oxc-B3KI3rf_.mjs
+function parseSourceFile(filePath, sourceText) {
+	const result = parseSync(filePath, sourceText, {
+		lang: filePath.endsWith(".tsx") ? "tsx" : "ts",
+		sourceType: "module",
+		astType: "ts",
+		preserveParens: true
+	});
+	if (result.errors.length > 0) throw new Error(`Failed to parse ${filePath}: ${result.errors.map((error) => error.message).join("; ")}`);
+	const lineStarts = computeLineStarts(sourceText);
+	const program = result.program;
+	return {
+		filePath,
+		sourceText,
+		program,
+		statements: program.body,
+		getLineAndCharacterOfPosition(position) {
+			return getLineAndCharacterOfPosition(lineStarts, position);
+		},
+		getText(node) {
+			return sourceText.slice(node.start, node.end);
+		}
+	};
+}
+function visitNode(node, visitor, parent = null) {
+	if (!isNode(node)) return;
+	if (visitor(node, parent) === false) return;
+	for (const key of visitorKeys[node.type] ?? []) {
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const child of value) if (isNode(child)) visitNode(child, visitor, node);
+		} else if (isNode(value)) visitNode(value, visitor, node);
+	}
+}
+function isNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string" && typeof value.start === "number" && typeof value.end === "number";
+}
+function identifierName(node) {
+	return isNode(node) && node.type === "Identifier" && typeof node.name === "string" ? node.name : void 0;
+}
+function literalString(node) {
+	return isNode(node) && node.type === "Literal" && typeof node.value === "string" ? node.value : void 0;
+}
+function literalNumber(node) {
+	return isNode(node) && node.type === "Literal" && typeof node.value === "number" ? node.value : void 0;
+}
+function propertyKeyName(node) {
+	if (!isNode(node)) return;
+	return identifierName(node) ?? literalString(node);
+}
+function unwrapExpression(expression) {
+	let current = expression;
+	while (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "ParenthesizedExpression") {
+		const nested = current.expression;
+		if (!isNode(nested)) break;
+		current = nested;
+	}
+	return current;
+}
+function getFirstObjectArgument(expression) {
+	if (expression.type !== "NewExpression" && expression.type !== "CallExpression") return null;
+	const [firstArgument] = Array.isArray(expression.arguments) ? expression.arguments : [];
+	const unwrapped = isNode(firstArgument) ? unwrapExpression(firstArgument) : null;
+	return unwrapped?.type === "ObjectExpression" ? unwrapped : null;
+}
+function readStringProperty(objectExpression, propertyName, stringBindings) {
+	const value = readPropertyValue(objectExpression, propertyName);
+	return value ? readStringExpression(value, stringBindings) : void 0;
+}
+function readPropertyValue(objectExpression, propertyName) {
+	if (!objectExpression) return null;
+	for (const property of objectExpression.properties) {
+		if (property.type !== "Property" || property.kind !== "init") continue;
+		if (propertyKeyName(property.key) === propertyName && isNode(property.value)) return property.value;
+	}
+	return null;
+}
+function readStringExpression(expression, stringBindings) {
+	const unwrapped = unwrapExpression(expression);
+	const literal = literalString(unwrapped);
+	if (literal !== void 0) return literal;
+	const identifier = identifierName(unwrapped);
+	if (identifier && stringBindings) return stringBindings.get(identifier);
+	if (unwrapped.type === "TemplateLiteral" && Array.isArray(unwrapped.expressions) && unwrapped.expressions.length === 0 && Array.isArray(unwrapped.quasis)) {
+		const [quasi] = unwrapped.quasis;
+		const value = isNode(quasi) ? quasi.value : void 0;
+		return typeof value === "object" && value !== null && "cooked" in value ? value.cooked ?? void 0 : void 0;
+	}
+}
+function computeLineStarts(sourceText) {
+	const starts = [0];
+	for (let index = 0; index < sourceText.length; index += 1) if (sourceText.charCodeAt(index) === 10) starts.push(index + 1);
+	return starts;
+}
+function getLineAndCharacterOfPosition(lineStarts, position) {
+	let low = 0;
+	let high = lineStarts.length - 1;
+	while (low <= high) {
+		const middle = Math.floor((low + high) / 2);
+		const start = lineStarts[middle] ?? 0;
+		const next = lineStarts[middle + 1] ?? Number.POSITIVE_INFINITY;
+		if (position < start) high = middle - 1;
+		else if (position >= next) low = middle + 1;
+		else return {
+			line: middle,
+			character: position - start
+		};
+	}
+	const lastLine = Math.max(0, lineStarts.length - 1);
+	return {
+		line: lastLine,
+		character: position - (lineStarts[lastLine] ?? 0)
+	};
+}
+//#endregion
+export { literalString as a, readStringProperty as c, literalNumber as i, unwrapExpression as l, identifierName as n, parseSourceFile as o, isNode as r, readPropertyValue as s, getFirstObjectArgument as t, visitNode as u };

package/dist/paused.handler-BMFm9Cff.mjs

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+import { D as throwReportedCliExit, h as toErrorMessage, t as ui } from "./keystroke.mjs";
+import { i as writeJson } from "./output-DM4b7KgY.mjs";
+import { i as requireClient } from "./context-T7HZuB97.mjs";
+//#region src/commands/workflows/paused/paused.handler.ts
+async function handleWorkflowsPaused(options, ctx) {
+	const client = requireClient(ctx);
+	try {
+		const match = await listPausedRuns(client, options);
+		if (ctx.jsonMode) {
+			writeJson(match.result);
+			return;
+		}
+		if (match.result.runs.length === 0) {
+			if (options.workflow) {
+				ui.hint(`No paused runs found for workflow "${options.workflow}".`);
+				return;
+			}
+			ui.hint("No paused workflow runs found.");
+			return;
+		}
+		if (options.workflow) {
+			if (match.kind === "authoredId") ui.hint(`Showing paused runs matching workflow id "${options.workflow}".`);
+			else if (match.kind === "name") ui.hint(`Showing paused runs matching workflow name "${options.workflow}".`);
+		}
+		for (const [index, run] of match.result.runs.entries()) {
+			ui.text(renderPausedRun(run));
+			if (index < match.result.runs.length - 1) ui.br();
+		}
+		ui.hint(`Showing ${match.result.runs.length} paused run(s)${options.type ? ` filtered to ${options.type}` : ""}.`);
+	} catch (error) {
+		ui.error(`Failed to list paused workflow runs: ${toErrorMessage(error)}`);
+		throwReportedCliExit(`Failed to list paused workflow runs: ${toErrorMessage(error)}`, { cause: error });
+	}
+}
+async function listPausedRuns(client, options) {
+	if (!options.workflow) return {
+		kind: "all",
+		result: await client.runs.listPausedRuns({
+			type: options.type,
+			limit: options.limit
+		})
+	};
+	const byAuthoredId = await client.runs.listPausedRuns({
+		authoredWorkflowId: options.workflow,
+		type: options.type,
+		limit: options.limit
+	});
+	if (byAuthoredId.runs.length > 0) return {
+		kind: "authoredId",
+		result: byAuthoredId
+	};
+	return {
+		kind: "name",
+		result: await client.runs.listPausedRuns({
+			workflowName: options.workflow,
+			type: options.type,
+			limit: options.limit
+		})
+	};
+}
+function renderPausedRun(run) {
+	const lines = [
+		`Workflow: ${run.workflowName} (${run.authoredWorkflowId})`,
+		`Run: ${run.id}`,
+		`Pause: ${run.pause.type} since ${formatTimestamp(run.pausedAt)} (${formatAge(run.ageMs)})`,
+		`Status: ${run.status} | Holds slot: ${run.holdsExecutionSlot ? "yes" : "no"}`,
+		`Progress: ${run.progress.completedStepsCount} completed${run.progress.lastCompletedStep ? ` | Last: ${run.progress.lastCompletedStep.stepName}` : ""}`
+	];
+	if (run.progress.completedSteps.length > 0) lines.push(`Completed steps: ${run.progress.completedSteps.map((step) => step.stepName).join(", ")}`);
+	if (run.activePauses.length > 1) lines.push(`Active pauses: ${run.activePauses.map((pause) => pause.type).join(", ")} (${run.activePauses.length})`);
+	if (run.pause.type === "wait") {
+		lines.push(`Resume at: ${formatTimestamp(run.pause.resumeAt)}`);
+		lines.push(`Wait duration: ${formatAge(run.pause.durationMs)}`);
+		lines.push(`Overdue: ${run.pause.overdue ? "yes" : "no"}`);
+	} else {
+		lines.push(`Approvals: ${run.pause.approvals}/${run.pause.requiredApprovals}`);
+		if (run.pause.expiresAt) lines.push(`Expires at: ${formatTimestamp(run.pause.expiresAt)}`);
+	}
+	return lines.join("\n");
+}
+function formatTimestamp(value) {
+	return new Date(value).toLocaleString();
+}
+function formatAge(ms) {
+	if (ms < 1e3) return `${ms}ms`;
+	if (ms < 6e4) return `${Math.floor(ms / 1e3)}s`;
+	if (ms < 36e5) return `${Math.floor(ms / 6e4)}m`;
+	if (ms < 864e5) return `${Math.floor(ms / 36e5)}h`;
+	return `${Math.floor(ms / 864e5)}d`;
+}
+//#endregion
+export { handleWorkflowsPaused };

package/dist/project-config-D1qsQlO7.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+import { access, mkdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { pathToFileURL } from "node:url";
+//#region ../../packages/workflow-core/src/config.ts
+/**
+* Canonical schema for the `build` field of a `keystroke.config.ts` file.
+*
+* This is the single source of truth for project-level build options.
+* Platform loaders (`@keystroke/project-config`) and type consumers re-use
+* this schema; nobody should redefine it downstream.
+*/
+const KeystrokeProjectBuildConfigSchema = z.object({ outDir: z.string().min(1).optional() });
+/**
+* Canonical schema for a Keystroke project's `keystroke.config.ts` file.
+*
+* This schema is the single source of truth for the shape a project
+* author writes with `defineConfig(...)`. Platform loaders
+* (`@keystroke/project-config`) re-use this schema to validate loaded
+* configs, and API / DB boundaries re-derive their contracts from it.
+*/
+const KeystrokeProjectConfigSchema = z.object({
+	name: z.string().min(1),
+	organizationId: z.uuid(),
+	projectId: z.uuid(),
+	description: z.string().min(1).optional(),
+	build: KeystrokeProjectBuildConfigSchema.optional()
+});
+//#endregion
+//#region ../../packages/project-config/src/config-content.ts
+function serializeConfigObject(config) {
+	return JSON.stringify(config, null, 2);
+}
+function createProjectConfigContent(config) {
+	return [
+		"import { defineConfig } from '@keystroke/workflow-core/config';",
+		"",
+		`export default defineConfig(${serializeConfigObject(config)});`,
+		""
+	].join("\n");
+}
+//#endregion
+//#region ../../packages/project-config/src/constants.ts
+const KEYSTROKE_PROJECT_CONFIG_FILE_NAME = "keystroke.config.ts";
+//#endregion
+//#region ../../packages/project-config/src/project-config.ts
+/** Walks up from startDir looking for keystroke.config.ts. Returns the containing directory, or null if not found. */
+async function findProjectRoot(startDir) {
+	let currentDir = path.resolve(startDir);
+	while (true) {
+		try {
+			await access(path.join(currentDir, KEYSTROKE_PROJECT_CONFIG_FILE_NAME));
+			return currentDir;
+		} catch {}
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+}
+/** Reads and validates keystroke.config.ts from projectRoot. Returns null if the file is missing or invalid. */
+async function readProjectConfig(projectRoot) {
+	try {
+		return await loadProjectConfig(projectRoot);
+	} catch {
+		return null;
+	}
+}
+/** Validates and writes keystroke.config.ts to projectRoot. Creates parent directories if needed. */
+async function writeProjectConfig(projectRoot, config) {
+	const validatedConfig = KeystrokeProjectConfigSchema.parse(config);
+	const configPath = getProjectConfigPath(projectRoot);
+	await mkdir(path.dirname(configPath), { recursive: true });
+	await writeFile(configPath, createProjectConfigContent(validatedConfig), "utf-8");
+}
+/** Reads and validates keystroke.config.ts, throwing a descriptive error if missing or invalid. */
+async function assertWorkflowProjectRoot(projectRoot) {
+	const resolvedProjectRoot = path.resolve(projectRoot);
+	const configPath = getProjectConfigPath(resolvedProjectRoot);
+	try {
+		await access(configPath);
+	} catch {
+		throw new Error(`Missing ${KEYSTROKE_PROJECT_CONFIG_FILE_NAME} in workflow root: ${resolvedProjectRoot}`);
+	}
+	try {
+		return await loadProjectConfig(resolvedProjectRoot);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown config load failure";
+		throw new Error(`Invalid ${KEYSTROKE_PROJECT_CONFIG_FILE_NAME}: ${message} (in ${resolvedProjectRoot})`);
+	}
+}
+function getProjectConfigPath(projectRoot) {
+	return path.join(path.resolve(projectRoot), KEYSTROKE_PROJECT_CONFIG_FILE_NAME);
+}
+async function loadProjectConfig(projectRoot) {
+	const configModule = await importConfigModule(getProjectConfigPath(projectRoot));
+	return KeystrokeProjectConfigSchema.parse(configModule.default);
+}
+async function importConfigModule(configPath) {
+	const configUrl = pathToFileURL(configPath);
+	const configStat = await stat(configPath);
+	configUrl.searchParams.set("t", String(configStat.mtimeMs));
+	return await import(configUrl.href);
+}
+//#endregion
+export { writeProjectConfig as a, readProjectConfig as i, findProjectRoot as n, getProjectConfigPath as r, assertWorkflowProjectRoot as t };