@keystrokehq/cli 0.0.1

package/dist/agent-manifest-CDnbkR2f.mjs

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+
+import { z } from "zod";
+//#region ../../packages/shared-types/src/deployments/api/agent-manifest.ts
+/**
+* Sandbox bootstrap artifact schema - describes an immutable artifact
+* that will be placed in the sandbox environment.
+*/
+const SandboxBootstrapArtifactSchema = z.object({
+	storagePath: z.string(),
+	sha256: z.string(),
+	target: z.string(),
+	kind: z.enum([
+		"file",
+		"directory",
+		"archive"
+	])
+});
+//#endregion
+//#region ../../packages/shared-types/src/workflows/domain/agent-manifest.ts
+const IntegrationScopeSchema = z.enum([
+	"organization",
+	"project",
+	"user_provided_credential"
+]);
+const JsonSchemaSchema = z.record(z.string(), z.unknown());
+const CredentialSetProxyInjectionSchema = z.object({
+	headers: z.boolean().optional(),
+	basicAuth: z.boolean().optional(),
+	queryParams: z.boolean().optional(),
+	body: z.boolean().optional()
+});
+const CredentialSetProxyConfigSchema = z.object({
+	hosts: z.array(z.string().min(1)).optional(),
+	hostPatterns: z.array(z.string().min(1)).optional(),
+	injection: CredentialSetProxyInjectionSchema.optional()
+});
+const ResolvedCredentialSetIdSchema = z.string().trim().min(1).max(255).refine((value) => /^[a-zA-Z0-9_-]+(:[a-zA-Z0-9_-]+)?$/.test(value), { error: "resolvedId must be a valid credential set ID, optionally namespaced (e.g. \"slack\" or \"keystroke:slack\")" });
+const McpTransportSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("stdio"),
+		command: z.string().trim().min(1),
+		args: z.array(z.string()).optional(),
+		env: z.record(z.string(), z.string()).optional()
+	}),
+	z.object({
+		type: z.literal("http"),
+		url: z.string().trim().min(1),
+		headers: z.record(z.string(), z.string()).optional()
+	}),
+	z.object({
+		type: z.literal("sse"),
+		url: z.string().trim().min(1),
+		headers: z.record(z.string(), z.string()).optional()
+	})
+]);
+const McpCredentialReferenceSchema = z.object({
+	credentialSetId: z.string().trim().min(1),
+	key: z.string().trim().min(1)
+});
+const McpCredentialBindingsSchema = z.object({
+	env: z.record(z.string(), McpCredentialReferenceSchema).optional(),
+	headers: z.record(z.string(), McpCredentialReferenceSchema).optional()
+});
+const AgentMcpCredentialSetSchema = z.object({
+	id: z.string().trim().min(1),
+	resolvedId: ResolvedCredentialSetIdSchema,
+	credentialKeys: z.array(z.string()),
+	/** Persistence-layer schema fingerprint (same contract as workflow manifests). */
+	schemaFingerprint: z.string().min(1).optional()
+});
+const AgentMcpServerSchema = z.object({
+	id: z.string().trim().min(1),
+	name: z.string().trim().min(1),
+	description: z.string().optional(),
+	transport: McpTransportSchema,
+	credentialSets: z.array(AgentMcpCredentialSetSchema).default([]),
+	credentialInjection: McpCredentialBindingsSchema.optional()
+});
+const AgentToolSuspensionReasonSchema = z.object({
+	kind: z.enum([
+		"wait",
+		"hook",
+		"child-workflow-suspending",
+		"agent",
+		"long-step"
+	]),
+	location: z.unknown().optional(),
+	detail: z.string(),
+	stepId: z.string().optional(),
+	hookName: z.string().optional(),
+	authoredWorkflowId: z.string().optional()
+});
+const AgentRuntimeModeSchema = z.enum(["pi_session"]);
+const AgentRuntimePlacementSchema = z.object({
+	cwd: z.literal("/home/user"),
+	piRoot: z.literal("/home/user/.pi")
+});
+const AgentRuntimeSchema = z.object({
+	mode: AgentRuntimeModeSchema,
+	placement: AgentRuntimePlacementSchema
+});
+/**
+* Mirrors `SandboxFileSourceSchema` from `@keystroke/workflow-core` so this
+* package stays free of a runtime dependency on workflow-core. Keep in sync
+* with `packages/workflow-core/src/sandbox/schemas.ts`.
+*/
+const AgentSandboxFileSourceSchema = z.discriminatedUnion("type", [z.object({
+	type: z.literal("git"),
+	url: z.string().trim().min(1),
+	branch: z.string().optional(),
+	/** Workdir-relative or absolute (under `/workspace`) clone destination. */
+	target: z.string().optional()
+}), z.object({
+	type: z.literal("local"),
+	/** Host source path (resolved against project root at deploy time). */
+	path: z.string().trim().min(1),
+	/** Workdir-relative or absolute (under `/workspace`) destination in the VM. */
+	target: z.string().optional()
+})]);
+/**
+* `workdir` here mirrors the workflow-core constraint: must be `/workspace`
+* or a subdirectory so it lands inside the persistent bind mount.
+*/
+const AgentSandboxWorkdirSchema = z.string().trim().min(1).refine((value) => value === "/workspace" || value.startsWith("/workspace/"), { error: "workdir must be \"/workspace\" or a subdirectory of \"/workspace\"" });
+const AgentSandboxSchema = z.object({
+	snapshotId: z.string().optional(),
+	runtime: z.object({
+		/**
+		* Runs every boot (after `setupCommands`, after a snapshot warm-boot
+		* where setupCommands are skipped). Use for `git pull`, `pnpm build`,
+		* etc. Each command runs with `cwd = workdir`.
+		*/
+		runCommands: z.array(z.string()).default([]),
+		env: z.record(z.string(), z.string()).default({}),
+		workdir: AgentSandboxWorkdirSchema.optional()
+	}).optional(),
+	/**
+	* Bootstrap-phase commands. Marker-gated; future snapshot warm-boots skip
+	* these entirely. Use for one-time, cacheable setup (e.g. `npm install -g`).
+	*/
+	setupCommands: z.array(z.string()).optional(),
+	/** File sources resolved at runtime. `git` clones happen in-VM during bootstrap. */
+	fileSources: z.array(AgentSandboxFileSourceSchema).optional(),
+	bootstrapArtifacts: z.array(SandboxBootstrapArtifactSchema).optional(),
+	sandboxBundleStoragePath: z.string().optional()
+});
+/**
+* Canonical agent version manifest schema - describes runtime metadata
+* for a versioned agent bundle and its session-based execution contract.
+*/
+const AgentVersionManifestSchema = z.object({
+	/** Database-generated or manifest-level agent identifier */
+	agentId: z.string(),
+	/** User-authored slug identifier. Primary key for all lookups. */
+	authoredAgentId: z.string(),
+	/** Human-readable display name. Do not use for lookups. */
+	agentName: z.string(),
+	displayName: z.string().optional(),
+	runtimeKind: z.enum(["declarative", "runnable"]).optional(),
+	exportName: z.string(),
+	mode: z.literal("sandbox"),
+	bundleHash: z.string(),
+	bundleSize: z.number(),
+	runtime: AgentRuntimeSchema.optional(),
+	systemPrompt: z.string().optional(),
+	model: z.string().optional(),
+	thinkingLevel: z.enum([
+		"off",
+		"minimal",
+		"low",
+		"medium",
+		"high",
+		"xhigh"
+	]).optional(),
+	maxSteps: z.number().optional(),
+	enableMemory: z.boolean().default(true),
+	enableDatabase: z.boolean().default(true),
+	inputSchema: JsonSchemaSchema.optional(),
+	outputSchema: JsonSchemaSchema.optional(),
+	tools: z.array(z.object({
+		toolName: z.string(),
+		description: z.string().optional(),
+		sourceKind: z.enum([
+			"operation",
+			"workflow",
+			"auto-injected-toolkit"
+		]).optional(),
+		authoredOperationId: z.string().optional(),
+		authoredWorkflowId: z.string().optional(),
+		deploymentId: z.string().optional(),
+		/**
+		* Dispatch placement for operation tools; computed by the builder from
+		* official integration metadata. `host` for hosted integrations, otherwise
+		* `sandbox`. Not set for workflow tools (their dispatch is derived from
+		* suspension classification + child workflow placement).
+		*/
+		dispatch: z.enum(["sandbox", "host"]).optional(),
+		invocation: z.enum(["sync", "yield"]).optional(),
+		largeResultMode: z.enum(["reject", "ref"]).optional(),
+		midSessionSnapshot: z.boolean().optional(),
+		suspensions: z.array(AgentToolSuspensionReasonSchema).optional(),
+		credentialSets: z.array(z.object({
+			id: ResolvedCredentialSetIdSchema,
+			required: z.boolean().default(true)
+		})).optional(),
+		/**
+		* Whether the tool's output schema is a non-empty array of objects.
+		* Computed by the builder via `isTabularSchema(tool.output)`. Lets
+		* runtime UIs render tabular tool results without re-introspecting
+		* the schema.
+		*/
+		outputSchemaIsTabular: z.boolean().optional()
+	})).optional(),
+	credentialSets: z.array(z.object({
+		resolvedId: ResolvedCredentialSetIdSchema,
+		scope: IntegrationScopeSchema.optional(),
+		credentialKeys: z.array(z.string()),
+		/** Subset of `credentialKeys` that may be absent from the vault
+		* without failing resolution. Derived at build time from the
+		* credential set's `auth` schema. */
+		optionalCredentialKeys: z.array(z.string()).optional(),
+		proxy: CredentialSetProxyConfigSchema.optional(),
+		needsRawSecret: z.boolean().optional(),
+		/** Persistence-layer schema fingerprint (same contract as workflow manifests). */
+		schemaFingerprint: z.string().min(1).optional()
+	})).optional(),
+	mcpServers: z.array(AgentMcpServerSchema).optional(),
+	messaging: z.array(z.object({
+		id: z.string(),
+		name: z.string(),
+		provider: z.string(),
+		mode: z.enum(["platform", "custom"]),
+		credentialSet: z.object({
+			resolvedId: ResolvedCredentialSetIdSchema,
+			credentialKeys: z.array(z.string()),
+			/** Persistence-layer schema fingerprint (same contract as workflow manifests). */
+			schemaFingerprint: z.string().min(1).optional()
+		}),
+		appRef: z.string().optional()
+	})).optional(),
+	sandbox: AgentSandboxSchema.optional()
+});
+//#endregion
+export { AgentVersionManifestSchema as t };

package/dist/agents-CZJGxVqV.mjs

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+
+import { D as throwReportedCliExit, h as toErrorMessage, o as ANSI, s as style, t as ui } from "./keystroke.mjs";
+import { d as trackProject } from "./dist-CUK7yBM0.mjs";
+import { i as writeJson, n as JsonOptionSchema, t as JSON_OPTION_CONFIG } from "./output-DM4b7KgY.mjs";
+import { t as createTypedCommand } from "./commander-DfTVqQ-3.mjs";
+import { i as readAgentManifestsFromOutDir } 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";
+import { i as resolveTypeHint } from "./schema-display-CgmeKigW.mjs";
+import { z } from "zod";
+//#region src/commands/agents/inspect-display.ts
+function renderAgentManifestInspect(manifest, options = {}) {
+	const displayName = manifest.displayName ?? manifest.agentName;
+	ui.text(style(`  Agent: ${manifest.authoredAgentId} (${displayName})`, `${ANSI.bold}${ANSI.cyan}`));
+	ui.text(style(`  Manifest agent id: ${manifest.agentId}`, ANSI.dim));
+	if (manifest.model) ui.text(`  Model: ${manifest.model}`);
+	if (manifest.runtimeKind) ui.text(`  Runtime kind: ${manifest.runtimeKind}`);
+	if (manifest.systemPrompt) ui.text(`  System prompt: ${formatPromptPreview(manifest.systemPrompt)}`);
+	ui.br();
+	ui.text(style("  Input", ANSI.bold));
+	const inputFields = formatSchemaFields(manifest.inputSchema);
+	ui.text(inputFields || style("    (none)", ANSI.dim));
+	ui.br();
+	ui.text(style("  Output", ANSI.bold));
+	const outputFields = formatSchemaFields(manifest.outputSchema);
+	ui.text(outputFields || style("    (none)", ANSI.dim));
+	ui.br();
+	ui.text(style("  Tools", ANSI.bold));
+	const tools = formatTools(manifest.tools ?? []);
+	ui.text(tools || style("    (none)", ANSI.dim));
+	ui.br();
+	const credentialSets = formatCredentialSets(manifest.credentialSets ?? []);
+	if (credentialSets) {
+		ui.text(style("  Credential Sets", ANSI.bold));
+		ui.text(credentialSets);
+		ui.br();
+	}
+	if (manifest.mcpServers?.length) {
+		ui.text(style("  MCP Servers", ANSI.bold));
+		ui.text(manifest.mcpServers.map((server) => `    ${server.id} (${server.name})`).join("\n"));
+		ui.br();
+	}
+	if (manifest.messaging?.length) {
+		ui.text(style("  Messaging Gateways", ANSI.bold));
+		ui.text(manifest.messaging.map((gateway) => `    ${gateway.id} (${gateway.provider}/${gateway.mode})`).join("\n"));
+		ui.br();
+	}
+	if (options.manifestPath) ui.text(style(`  Manifest: ${options.manifestPath}`, ANSI.dim));
+}
+function formatTools(tools) {
+	if (tools.length === 0) return "";
+	return tools.map(formatTool).join("\n");
+}
+function formatCredentialSets(credentialSets) {
+	if (credentialSets.length === 0) return "";
+	return credentialSets.map((credentialSet) => {
+		const scope = credentialSet.scope ? ` (${credentialSet.scope})` : "";
+		const keys = credentialSet.credentialKeys.length > 0 ? ` keys: ${credentialSet.credentialKeys.join(", ")}` : "";
+		return `    ${credentialSet.resolvedId}${scope}${keys}`;
+	}).join("\n");
+}
+function formatSchemaFields(schema) {
+	if (!schema || typeof schema !== "object") return "";
+	const props = schema.properties;
+	if (!props || Object.keys(props).length === 0) return "";
+	const required = schema.required ?? [];
+	const requiredSet = new Set(required);
+	const lines = [];
+	for (const [name, fieldSchema] of Object.entries(props)) {
+		const typeHint = resolveTypeHint(fieldSchema);
+		const req = requiredSet.has(name) ? style("  required", ANSI.dim) : "";
+		lines.push(`    ${name}  ${style(typeHint, ANSI.dim)}${req}`);
+	}
+	return lines.join("\n");
+}
+function formatTool(tool) {
+	const lines = [`    ${tool.toolName}`];
+	if (tool.description) lines.push(`      ${style(tool.description, ANSI.dim)}`);
+	const fields = [
+		["sourceKind", tool.sourceKind],
+		["authoredOperationId", tool.authoredOperationId],
+		["authoredWorkflowId", tool.authoredWorkflowId],
+		["deploymentId", tool.deploymentId],
+		["invocation", tool.invocation],
+		["largeResultMode", tool.largeResultMode],
+		["midSessionSnapshot", formatOptionalBoolean(tool.midSessionSnapshot)]
+	].filter((entry) => typeof entry[1] === "string");
+	for (const [label, value] of fields) lines.push(`      ${label}: ${value}`);
+	if (tool.credentialSets?.length) {
+		const credentials = tool.credentialSets.map((credentialSet) => {
+			const required = credentialSet.required ? "required" : "conditional";
+			return `${credentialSet.id} (${required})`;
+		});
+		lines.push(`      credentialSets: [${credentials.join(", ")}]`);
+	}
+	return lines.join("\n");
+}
+function formatOptionalBoolean(value) {
+	if (value === void 0) return;
+	return value ? "true" : "false";
+}
+function formatPromptPreview(prompt) {
+	const compact = prompt.replace(/\s+/g, " ").trim();
+	if (compact.length <= 120) return compact;
+	return `${compact.slice(0, 117)}...`;
+}
+//#endregion
+//#region src/commands/agents/inspect.handler.ts
+const agentInspectDependencies = {
+	readAgentManifestsFromOutDir,
+	runWorkflowBuild
+};
+async function handleAgentsInspect(options, ctx) {
+	const resolved = await resolveAgentManifest(options.agent, options.path, { jsonMode: ctx.jsonMode });
+	trackProject(resolved.workflowsDir);
+	if (ctx.jsonMode) {
+		writeJson({
+			manifest: resolved.manifest,
+			manifestPath: resolved.manifestPath
+		});
+		return;
+	}
+	renderAgentManifestInspect(resolved.manifest, { manifestPath: resolved.manifestPath });
+}
+async function resolveAgentManifest(agentRef, explicitPath, options) {
+	const workflowsDir = await requireWorkflowsDir(explicitPath);
+	let matches = await findAgentManifest(workflowsDir, agentRef);
+	if (matches.length === 0) {
+		const spinner = options.jsonMode ? void 0 : createSpinnerProgress("[resolve]");
+		spinner?.start(`Building agents to resolve "${agentRef}"...`);
+		try {
+			await agentInspectDependencies.runWorkflowBuild({
+				workflowsDir,
+				verbose: false,
+				force: false
+			});
+			spinner?.stop();
+		} catch (error) {
+			spinner?.stop();
+			renderBuildFailure(error);
+			throwReportedCliExit(`Build failed while resolving agent "${agentRef}".`, { cause: error });
+		}
+		matches = await findAgentManifest(workflowsDir, agentRef);
+	}
+	if (matches.length === 0) {
+		const available = await listAvailableAgentRefs(workflowsDir);
+		ui.error(`Agent "${agentRef}" not found.`);
+		if (available.length > 0) ui.hint(`Available agents: ${available.join(", ")}`);
+		else ui.hint("No built agent manifests were found. Run `keystroke workflows build` and try again.");
+		throwReportedCliExit(`Agent "${agentRef}" not found.`);
+	}
+	if (matches.length > 1) {
+		ui.error(`Agent reference "${agentRef}" matched multiple agent manifests.`);
+		for (const match of matches) ui.hint(`- ${match.manifest.authoredAgentId} (${match.manifest.agentName}) at ${match.manifestPath}`);
+		ui.hint("Use the authored agent id to inspect one manifest.");
+		throwReportedCliExit(`Agent reference "${agentRef}" matched multiple agent manifests.`);
+	}
+	const match = matches[0];
+	if (!match) throwReportedCliExit(`Agent "${agentRef}" not found.`);
+	return {
+		workflowsDir,
+		manifest: match.manifest,
+		manifestPath: match.manifestPath
+	};
+}
+async function findAgentManifest(workflowsDir, agentRef) {
+	try {
+		return (await agentInspectDependencies.readAgentManifestsFromOutDir(workflowsDir)).filter(({ manifest }) => manifestMatchesRef(manifest, agentRef));
+	} catch (error) {
+		ui.error(`Failed to read built agent manifests: ${toErrorMessage(error)}`);
+		throwReportedCliExit(`Failed to read built agent manifests: ${toErrorMessage(error)}`, { cause: error });
+	}
+}
+async function listAvailableAgentRefs(workflowsDir) {
+	return (await agentInspectDependencies.readAgentManifestsFromOutDir(workflowsDir)).map(({ manifest }) => manifest.authoredAgentId || manifest.agentName || manifest.agentId).filter((value) => Boolean(value)).sort((left, right) => left.localeCompare(right));
+}
+function manifestMatchesRef(manifest, agentRef) {
+	return [
+		manifest.authoredAgentId,
+		manifest.agentId,
+		manifest.agentName,
+		manifest.displayName,
+		manifest.exportName
+	].some((value) => value === agentRef);
+}
+//#endregion
+//#region src/commands/agents/agents.command.ts
+const AgentsOptionsSchema = JsonOptionSchema.extend({ path: z.string().optional() });
+const AgentsInspectOptionsSchema = AgentsOptionsSchema.extend({ agent: z.string().min(1) });
+const AGENTS_OPTIONS_CONFIG = {
+	...JSON_OPTION_CONFIG,
+	path: {
+		flag: "--path <dir>",
+		description: "Path to project root (directory containing keystroke.config.ts); auto-discovered from CWD if omitted"
+	}
+};
+const AGENTS_INSPECT_OPTIONS_CONFIG = { ...AGENTS_OPTIONS_CONFIG };
+function handleAgentsHelp() {
+	ui.hint("Use `keystroke agents inspect <agentId>` to inspect a built agent manifest.");
+}
+function createAgentsCommand() {
+	const cmd = createTypedCommand({
+		name: "agents",
+		description: "Inspect and debug agents",
+		schema: AgentsOptionsSchema,
+		optionsConfig: AGENTS_OPTIONS_CONFIG,
+		handler: handleAgentsHelp,
+		subcommands: [createTypedCommand({
+			name: "inspect",
+			description: "Show the built manifest for an agent",
+			schema: AgentsInspectOptionsSchema,
+			optionsConfig: AGENTS_INSPECT_OPTIONS_CONFIG,
+			argument: {
+				name: "agent",
+				description: "Authored agent id (preferred), agent id, or agent name",
+				key: "agent"
+			},
+			handler: handleAgentsInspect
+		})]
+	});
+	cmd.enablePositionalOptions();
+	cmd.passThroughOptions();
+	return cmd;
+}
+//#endregion
+export { createAgentsCommand };

package/dist/api-keys-D2lgguuY.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+import { n as JsonOptionSchema, t as JSON_OPTION_CONFIG } from "./output-DM4b7KgY.mjs";
+import { t as createTypedCommand } from "./commander-DfTVqQ-3.mjs";
+import { z } from "zod";
+//#region src/commands/api-keys/api-keys.command.ts
+const ApiKeysDeleteOptionsSchema = z.object({ apiKeyId: z.string() });
+const DELETE_OPTIONS_CONFIG = { apiKeyId: {
+	flag: "",
+	description: ""
+} };
+function createApiKeysCommand() {
+	return createTypedCommand({
+		name: "api-keys",
+		description: "Manage API keys for your organization",
+		schema: JsonOptionSchema,
+		optionsConfig: { ...JSON_OPTION_CONFIG },
+		loadHandler: async () => (await import("./list.handler-DWaQkJaR.mjs")).handleApiKeysList,
+		subcommands: [createTypedCommand({
+			name: "list",
+			description: "List all API keys for your organization",
+			schema: JsonOptionSchema,
+			optionsConfig: { ...JSON_OPTION_CONFIG },
+			loadHandler: async () => (await import("./list.handler-DWaQkJaR.mjs")).handleApiKeysList
+		}), createTypedCommand({
+			name: "delete",
+			description: "Delete an API key by ID",
+			schema: ApiKeysDeleteOptionsSchema,
+			optionsConfig: DELETE_OPTIONS_CONFIG,
+			argument: {
+				name: "api-key-id",
+				description: "API key ID to delete",
+				key: "apiKeyId"
+			},
+			loadHandler: async () => (await import("./delete.handler-bAu1iXVQ.mjs")).handleApiKeysDelete
+		})]
+	});
+}
+//#endregion
+export { createApiKeysCommand };

package/dist/auth-DN2VusyU.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+import { g as AUTH_TIMEOUT_SECONDS } from "./keystroke.mjs";
+import { t as createTypedCommand } from "./commander-DfTVqQ-3.mjs";
+import { z } from "zod";
+//#region src/commands/auth/auth.command.ts
+const AuthOptionsSchema = z.object({
+	webUrl: z.url().optional().describe("Keystroke web URL"),
+	serverUrl: z.url().optional().describe("Keystroke API URL"),
+	timeout: z.coerce.number().int().min(AUTH_TIMEOUT_SECONDS.min).max(AUTH_TIMEOUT_SECONDS.max).default(AUTH_TIMEOUT_SECONDS.default).describe("Timeout in seconds")
+});
+const AUTH_OPTIONS_CONFIG = {
+	webUrl: {
+		flag: "--web-url <url>",
+		description: "Keystroke web URL (default: WEB_URL env)"
+	},
+	serverUrl: {
+		flag: "--server-url <url>",
+		description: "Keystroke API URL (default: SERVER_URL env)"
+	},
+	timeout: {
+		flag: "--timeout <seconds>",
+		description: `Authentication timeout in seconds (default: ${AUTH_TIMEOUT_SECONDS.default})`
+	}
+};
+function createAuthCommand() {
+	return createTypedCommand({
+		name: "auth",
+		description: "Authenticate Keystroke CLI via device flow",
+		schema: AuthOptionsSchema,
+		optionsConfig: AUTH_OPTIONS_CONFIG,
+		loadHandler: async () => (await import("./auth.handler-CT1BQUvu.mjs")).handleAuth,
+		subcommands: [
+			createTypedCommand({
+				name: "clear",
+				description: "Revoke the saved API key and remove local credentials",
+				schema: z.object({}),
+				optionsConfig: {},
+				loadHandler: async () => (await import("./clear.handler-BTIXXPTJ.mjs")).handleAuthClear
+			}),
+			createTypedCommand({
+				name: "test",
+				description: "Verify that the saved API key is valid",
+				schema: z.object({}),
+				optionsConfig: {},
+				loadHandler: async () => (await import("./test.handler-BcPQ8b74.mjs")).handleAuthTest
+			}),
+			createTypedCommand({
+				name: "status",
+				description: "Show the current signed-in identity and organization context",
+				schema: z.object({}),
+				optionsConfig: {},
+				loadHandler: async () => (await import("./status.handler-BO4nwvWn.mjs")).handleAuthStatus
+			})
+		]
+	});
+}
+//#endregion
+export { createAuthCommand };