@runtypelabs/cli 2.59.1 → 2.59.4

package/dist/chunk-PrFjcpmH.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+import { t as isTTY } from "./index.js";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { ErrorDisplay, Spinner, theme } from "@runtypelabs/ink-components";
+import { jsx, jsxs } from "react/jsx-runtime";
+// src/ink/shared/altScreen.ts
+/**
+* Enter the terminal's alternate screen buffer for fullscreen TUI apps.
+* Fullscreen apps use the alternate screen so rendering doesn't pollute scrollback history.
+* Returns a cleanup function that restores the original screen.
+* Cleanup is idempotent and also registered on process 'exit' as a safety net.
+*/
+function enterAltScreen() {
+	if (!process.stdout.isTTY) return () => {};
+	process.stdout.write("\x1B[?1049h\x1B[2J\x1B[H");
+	let restored = false;
+	const restore = () => {
+		if (restored) return;
+		restored = true;
+		process.removeListener("exit", restore);
+		process.stdout.write("\x1B[?1049l");
+	};
+	process.on("exit", restore);
+	return restore;
+}
+// src/ink/shared/EntityCard.tsx
+function EntityCard({ fields, title }) {
+	const visibleFields = fields.filter((f) => f.value !== null && f.value !== void 0);
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		marginBottom: 1,
+		children: [title && /* @__PURE__ */ jsx(Text, {
+			color: theme.primary,
+			bold: true,
+			children: title
+		}), visibleFields.map((field, index) => /* @__PURE__ */ jsxs(Text, { children: [
+			"  ",
+			/* @__PURE__ */ jsxs(Text, {
+				color: theme.dimLabel,
+				children: [field.label, ":"]
+			}),
+			" ",
+			/* @__PURE__ */ jsx(Text, {
+				color: field.color || theme.label,
+				children: String(field.value)
+			})
+		] }, index))]
+	});
+}
+// src/ink/shared/ConfirmPrompt.tsx
+function ConfirmPrompt({ message, defaultValue = false, onConfirm }) {
+	const [answered, setAnswered] = useState(false);
+	const [result, setResult] = useState(null);
+	const hint = defaultValue ? "Y/n" : "y/N";
+	useInput((input, key) => {
+		if (answered) return;
+		const lower = input.toLowerCase();
+		if (lower === "y") {
+			setAnswered(true);
+			setResult(true);
+			onConfirm(true);
+		} else if (lower === "n") {
+			setAnswered(true);
+			setResult(false);
+			onConfirm(false);
+		} else if (key.return) {
+			setAnswered(true);
+			setResult(defaultValue);
+			onConfirm(defaultValue);
+		}
+	}, { isActive: !answered });
+	if (answered) return /* @__PURE__ */ jsxs(Text, { children: [
+		message,
+		" ",
+		/* @__PURE__ */ jsx(Text, {
+			color: result ? theme.success : theme.muted,
+			children: result ? "Yes" : "No"
+		})
+	] });
+	return /* @__PURE__ */ jsxs(Text, { children: [
+		message,
+		" ",
+		/* @__PURE__ */ jsxs(Text, {
+			color: theme.muted,
+			children: [
+				"(",
+				hint,
+				")"
+			]
+		})
+	] });
+}
+// src/ink/shared/DataList.tsx
+function DataList({ title, items, error, loading, renderCard, emptyMessage = "None found", total, onRetry, onDone }) {
+	const { exit } = useApp();
+	const hasDone = useRef(false);
+	useEffect(() => {
+		if (hasDone.current) return void 0;
+		if (loading) return void 0;
+		if (error && !onRetry) {
+			hasDone.current = true;
+			onDone?.();
+			const timer = setTimeout(() => exit(), 0);
+			return () => clearTimeout(timer);
+		}
+		if (items !== null) {
+			hasDone.current = true;
+			onDone?.();
+			const timer = setTimeout(() => exit(), 0);
+			return () => clearTimeout(timer);
+		}
+	}, [
+		loading,
+		error,
+		items,
+		onRetry,
+		onDone,
+		exit
+	]);
+	useInput((input) => {
+		if (input === "r" && error && onRetry) onRetry();
+	}, { isActive: !!error && !!onRetry });
+	if (loading) return /* @__PURE__ */ jsx(Spinner, { label: `Fetching ${title}...` });
+	if (error) return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [/* @__PURE__ */ jsx(ErrorDisplay, { error }), onRetry && /* @__PURE__ */ jsx(Text, {
+			color: theme.muted,
+			children: "Press 'r' to retry"
+		})]
+	});
+	if (items !== null && items.length === 0) return /* @__PURE__ */ jsx(Text, {
+		color: theme.muted,
+		children: emptyMessage
+	});
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsxs(Text, {
+				color: theme.primary,
+				bold: true,
+				children: [title, ":"]
+			}),
+			items?.map((item, index) => /* @__PURE__ */ jsx(Box, { children: renderCard(item) }, index)),
+			total !== void 0 && /* @__PURE__ */ jsxs(Text, {
+				dimColor: true,
+				children: [
+					"\n",
+					"  Total: ",
+					total
+				]
+			})
+		]
+	});
+}
+// src/ink/shared/MutationResult.tsx
+function MutationResult({ loading, loadingLabel = "Processing...", success, successMessage, result, error, onRetry, onDone }) {
+	const { exit } = useApp();
+	const hasDone = useRef(false);
+	useEffect(() => {
+		if (hasDone.current) return void 0;
+		if (loading) return void 0;
+		if (success === true) {
+			hasDone.current = true;
+			onDone?.();
+			const timer = setTimeout(() => exit(), 0);
+			return () => clearTimeout(timer);
+		}
+		if (success === false && !onRetry) {
+			hasDone.current = true;
+			onDone?.();
+			const timer = setTimeout(() => exit(), 0);
+			return () => clearTimeout(timer);
+		}
+		if (error && !onRetry) {
+			hasDone.current = true;
+			onDone?.();
+			const timer = setTimeout(() => exit(), 0);
+			return () => clearTimeout(timer);
+		}
+	}, [
+		loading,
+		success,
+		error,
+		onRetry,
+		onDone,
+		exit
+	]);
+	useInput((input) => {
+		if (input === "r" && (error || success === false) && onRetry) onRetry();
+	}, { isActive: !!(error || success === false) && !!onRetry });
+	if (loading) return /* @__PURE__ */ jsx(Spinner, { label: loadingLabel });
+	if (success === true) return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [/* @__PURE__ */ jsxs(Text, { children: [
+			/* @__PURE__ */ jsx(Text, {
+				color: theme.success,
+				children: "✓"
+			}),
+			" ",
+			successMessage || "Done"
+		] }), result]
+	});
+	if (error) return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [/* @__PURE__ */ jsx(ErrorDisplay, { error }), onRetry && /* @__PURE__ */ jsx(Text, {
+			color: theme.muted,
+			children: "Press 'r' to retry"
+		})]
+	});
+	return null;
+}
+// src/ink/shared/useMutationState.ts
+function useMutationState(initial = "loading") {
+	const [state, setState] = useState({ status: initial });
+	return {
+		state,
+		start: useCallback(() => setState({ status: "loading" }), []),
+		succeed: useCallback((result) => setState({
+			status: "success",
+			result
+		}), []),
+		fail: useCallback((error) => setState({
+			status: "error",
+			error: error instanceof Error ? error : new Error(String(error))
+		}), [])
+	};
+}
+/** The MutationResult props a lifecycle state renders as. */
+function mutationResultProps(state) {
+	switch (state.status) {
+		case "idle": return {
+			loading: false,
+			success: null,
+			error: null
+		};
+		case "loading": return {
+			loading: true,
+			success: null,
+			error: null
+		};
+		case "success": return {
+			loading: false,
+			success: true,
+			error: null,
+			result: state.result
+		};
+		case "error": return {
+			loading: false,
+			success: false,
+			error: state.error
+		};
+	}
+}
+export { ConfirmPrompt, DataList, EntityCard, MutationResult, enterAltScreen, isTTY, mutationResultProps, useMutationState };
+

package/dist/chunk-QSfNYiw9.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// ../shared/dist/chunk-CRRVsJap.mjs
+/**
+* Canonical record type guard: a non-null object that is NOT an array.
+* This is the array-EXCLUDING variant — `isRecord([])` is false.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export { isRecord as t };
+

package/dist/chunk-R265bzj9.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+import { S as union, b as string, c as boolean, f as literal, h as object, m as number, s as array, x as tuple } from "./chunk-BOpO6xE-.js";
+import { t as HARNESS_ATTRIBUTES } from "./chunk-Bu0FJr6S.js";
+/**
+* The same attribute names, exported for readers of GenAI spans.
+* OTLP trace ingest reads back the identical vocabulary a customer's own SDK produced.
+* A second hand-typed copy on the read side is a silent-drift hazard: a misspelling fails no build,
+* it just makes every ingested run report zero tokens.
+*/
+const GEN_AI_ATTRIBUTES = {
+	operationName: "gen_ai.operation.name",
+	agentId: "gen_ai.agent.id",
+	agentName: "gen_ai.agent.name",
+	conversationId: "gen_ai.conversation.id",
+	requestModel: "gen_ai.request.model",
+	usageInputTokens: "gen_ai.usage.input_tokens",
+	usageOutputTokens: "gen_ai.usage.output_tokens",
+	/** Input tokens served from the provider's prompt cache, when the provider reports them. */
+	usageCacheReadTokens: "gen_ai.usage.cache_read.input_tokens",
+	/** Input tokens written INTO the provider's prompt cache, when the provider reports them. */
+	usageCacheCreationTokens: "gen_ai.usage.cache_creation.input_tokens",
+	/** The model the provider reported having SERVED; the more accurate one to price. */
+	responseModel: "gen_ai.response.model",
+	toolName: "gen_ai.tool.name",
+	toolType: "gen_ai.tool.type",
+	toolCallId: "gen_ai.tool.call.id"
+};
+// ../shared/dist/context-manifest-wire.mjs
+const entryTupleSchema = union([tuple([
+	string(),
+	number().int(),
+	number().int(),
+	number().int(),
+	number().int(),
+	number().int(),
+	number().int()
+]), tuple([
+	string(),
+	number().int(),
+	number().int(),
+	number().int(),
+	number().int(),
+	number().int(),
+	number().int(),
+	string(),
+	string()
+])]);
+object({
+	v: literal(1),
+	s: number().int().nonnegative(),
+	e: array(entryTupleSchema),
+	b: array(number().int().nonnegative()),
+	x: array(tuple([entryTupleSchema, number().int()]))
+});
+object({
+	v: literal(1),
+	b: array(tuple([
+		string(),
+		string(),
+		union([literal(0), literal(1)])
+	]))
+});
+array(object({
+	hash: string(),
+	content: string(),
+	truncated: boolean()
+}));
+/**
+* The runtype.* extension attributes, keyed for readers and builders, at resource/invoke_agent/any-span/chat/approval levels.
+* agentId has two placements; the resource-level claim is authoritative, and the span placement is consulted only when absent.
+* Two envelope spans in one trace claiming different agentIds is ambiguous and refused, same as conflicting resource claims.
+* chat-span providerFinishReason/gatewayLogId are optional diagnostics and never count toward the achieved fidelity tier.
+*/
+const RUNTYPE_ATTRIBUTES = {
+	agentId: "runtype.agent.id",
+	/**
+	* The published agent version that produced the run, beside `agentId` (resource first, then the
+	* envelope). Ingest stamps it on the Run only when it names a version of the attributed agent.
+	*/
+	agentVersionId: "runtype.agent.version_id",
+	/** The release alias (`live`, `staging`, ...) the version was resolved through, when one was. */
+	agentAlias: "runtype.agent.alias",
+	/** The alias binding's revision at export time; provenance only, never a grouping key. */
+	agentAliasRevision: "runtype.agent.alias_revision",
+	schemaVersion: "runtype.schema.version",
+	adapterName: "runtype.adapter.name",
+	adapterVersion: "runtype.adapter.version",
+	executionId: "runtype.execution.id",
+	/**
+	* The execution that spawned this one, on the envelope span. Carried, never
+	* synthesized: a producer that names no parent leaves it absent, which is what
+	* keeps the header's partial index proportional to child runs.
+	*/
+	parentExecutionId: "runtype.parent.execution_id",
+	/**
+	* The parent's own tool-call id for the call that spawned this run, on the
+	* envelope span. The graft key: it is what grafts this trace under one
+	* `execute_tool` span of the parent rather than under the parent as a whole.
+	*/
+	parentToolCallId: "runtype.parent.tool_call_id",
+	iteration: "runtype.iteration",
+	/**
+	* The loop's own iteration COUNT, on the envelope. A producer whose iterations
+	* hold several model calls reports it so the run does not read as `highest
+	* position + 1`; readers prefer it over the positions when present.
+	*/
+	iterations: "runtype.iterations",
+	/**
+	* The producer's own USD cost claim for the run, on the envelope. Read only
+	* when no span carried a priceable model id; stored as self-reported cost,
+	* never billed (`cost-aggregation.ts` keeps it out of billed units).
+	*/
+	totalCost: "runtype.total_cost",
+	stopReason: "runtype.stop_reason",
+	toolsReported: "runtype.tools.reported",
+	toolType: "runtype.tool.type",
+	toolName: "runtype.tool.name",
+	approvalDecision: "runtype.approval.decision",
+	/**
+	* Identifier of ONE model invocation, on its `chat` span. An id, never
+	* content: it lets a host correlate a span with the usage report the same
+	* call produced (`RuntimeModelUsageReport.modelCallId`).
+	*/
+	modelCallId: "runtype.model.call_id",
+	turnId: "runtype.turn.id",
+	turnIndex: "runtype.turn.index",
+	/** The provider's raw finish value before normalization (2.x-only, provider-dependent). */
+	providerFinishReason: "runtype.provider.finish_reason",
+	/**
+	* The service tier the provider was asked for or served a model turn under
+	* (`flex`, `priority`, an Anthropic speed value). A `chat`-span diagnostic
+	* that survives on the retained span row; nothing projects it, and it never
+	* counts toward the achieved fidelity tier.
+	*/
+	providerServiceTier: "runtype.provider.service_tier",
+	/**
+	* The gateway log id for a model turn (e.g. Cloudflare AI Gateway's
+	* `cf-aig-log-id`), for correlating a specific turn with its entry in the
+	* gateway dashboard. A pointer to content without shipping the content.
+	* Emitted on `chat` spans only when the producer provides it.
+	*/
+	gatewayLogId: "runtype.gateway.log_id",
+	/**
+	* Test-plane only: names the e2e/smoke test run a span was exported under,
+	* so the test-trace-collector worker can shard storage one Durable Object
+	* per run. A resource attribute set by test harnesses; the production
+	* ingest lanes ignore it, and no production emitter sets it.
+	*/
+	testRunId: "runtype.test.run_id"
+};
+/**
+* GenAI semconv content attributes, set by a customer's own instrumentation when it opts into content export.
+* Two first-party producers write them: @runtypelabs/runtime's OTLP tracer for exported agents (content on by default), and @runtypelabs/flue-otel (opt-in).
+* Content read from these attributes is accepted only under the ingest-side scrub + caps posture.
+*/
+const GEN_AI_TOOL_CALL_ARGUMENTS = "gen_ai.tool.call.arguments";
+const GEN_AI_TOOL_CALL_RESULT = "gen_ai.tool.call.result";
+const GEN_AI_INPUT_MESSAGES = "gen_ai.input.messages";
+const GEN_AI_OUTPUT_MESSAGES = "gen_ai.output.messages";
+const GEN_AI_CONTENT_ATTRIBUTES = {
+	/** Chat history sent to the model, as semconv structured messages. */
+	inputMessages: GEN_AI_INPUT_MESSAGES,
+	/** Messages the model produced (includes reasoning content parts). */
+	outputMessages: GEN_AI_OUTPUT_MESSAGES,
+	/** System instructions, when separate from the input messages. */
+	systemInstructions: "gen_ai.system_instructions",
+	/** `execute_tool` span: the arguments the tool was called with. */
+	toolCallArguments: GEN_AI_TOOL_CALL_ARGUMENTS,
+	/** `execute_tool` span: the result the tool returned. */
+	toolCallResult: GEN_AI_TOOL_CALL_RESULT,
+	/** `chat` span: the tool schemas the call offered the model. */
+	toolDefinitions: "gen_ai.tool.definitions"
+};
+/**
+* Read-side aliases for content attributes: canonical semconv name to vendor-namespaced spellings a stock instrumentation uses.
+* The aliased value is read through the same budget+scrub path as the canonical name; keys must be canonical (test-pinned).
+*/
+const GEN_AI_CONTENT_ATTRIBUTE_ALIASES = {
+	[GEN_AI_INPUT_MESSAGES]: ["ai.prompt.messages", "ai.prompt"],
+	[GEN_AI_OUTPUT_MESSAGES]: ["ai.response.text", "ai.response.object"],
+	[GEN_AI_TOOL_CALL_ARGUMENTS]: ["flue.tool.call.arguments", "ai.toolCall.args"],
+	[GEN_AI_TOOL_CALL_RESULT]: ["flue.tool.call.result", "ai.toolCall.result"]
+};
+/**
+* OpenInference content, as LangGraph / OpenAI Agents SDK / every Arize instrumentation emits it.
+* A message array arrives flattened into indexed keys, so no 1:1 alias can name it; the OpenInference
+* normalizer reassembles the family into the canonical names above before anything reads it.
+*/
+const OPENINFERENCE_CONTENT_PREFIXES = [
+	"llm.input_messages.",
+	"llm.output_messages.",
+	"llm.tools.",
+	"llm.prompts",
+	"llm.prompt_template.",
+	"llm.choices",
+	"llm.function_call",
+	"retrieval.documents.",
+	"embedding.embeddings.",
+	"input.value",
+	"output.value"
+];
+/** Vercel AI SDK `experimental_telemetry` payloads with no canonical counterpart to alias onto. */
+const AI_SDK_CONTENT_PREFIXES = ["ai.response.toolCalls"];
+/** Mastra's raw provider response body; its sibling `mastra.metadata.*` keys are identifiers, not payloads. */
+const MASTRA_CONTENT_PREFIXES = ["mastra.metadata.body"];
+/**
+* The Cloudflare Agents SDK's two open-segment namespaces, holding whatever scalars the app put in
+* `experimental_telemetry.metadata` / `runtimeContext`. Cloudflare's own guidance is that context
+* filtering "is not a security boundary", and these are the one place a careless author stashes a
+* user message, so they are excluded whole rather than read.
+*/
+const CLOUDFLARE_AGENTS_CONTENT_PREFIXES = ["cloudflare.agents.metadata.", "cloudflare.agents.runtime_context."];
+[
+	...OPENINFERENCE_CONTENT_PREFIXES,
+	...AI_SDK_CONTENT_PREFIXES,
+	...MASTRA_CONTENT_PREFIXES,
+	...CLOUDFLARE_AGENTS_CONTENT_PREFIXES
+];
+[
+	HARNESS_ATTRIBUTES.nativeContent,
+	...Object.values(GEN_AI_CONTENT_ATTRIBUTES),
+	...Object.values(GEN_AI_CONTENT_ATTRIBUTE_ALIASES).flat()
+];
+GEN_AI_ATTRIBUTES.responseModel;
+export { RUNTYPE_ATTRIBUTES as n, GEN_AI_ATTRIBUTES as r, GEN_AI_CONTENT_ATTRIBUTES as t };
+

package/dist/chunk-X9V_r6jM.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+import { t as isTTY } from "./index.js";
+import { DataList, EntityCard, MutationResult, React, Text, render, useEffect, useState } from "./chunk-CoAWdSiE.js";
+import { r as createCliClient } from "./chunk-BW2fg46T.js";
+import { n as ensureAuth } from "./chunk-CJraEBVd.js";
+import { a as printJson, i as printDetail, r as getTotalCount } from "./chunk-CcFCyqbB.js";
+import { Command } from "commander";
+import chalk from "chalk";
+// src/commands/analytics.ts
+const analyticsCommand = new Command("analytics").description("View analytics and execution results");
+analyticsCommand.command("stats").description("Show account statistics").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.get("/analytics/stats");
+			if (options.json) printJson(data);
+			else printDetail("Account Statistics", [
+				{
+					label: "Flows",
+					value: data.flows
+				},
+				{
+					label: "Prompts",
+					value: data.prompts
+				},
+				{
+					label: "Records",
+					value: data.records
+				},
+				{
+					label: "Executions",
+					value: data.executions
+				}
+			]);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to fetch stats"));
+			console.error(chalk.red(message));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [success, setSuccess] = useState(null);
+		const [error, setError] = useState(null);
+		const [resultNode, setResultNode] = useState(void 0);
+		useEffect(() => {
+			const run = async () => {
+				try {
+					const data = await client.get("/analytics/stats");
+					setResultNode(React.createElement(EntityCard, { fields: [
+						{
+							label: "Flows",
+							value: data.flows
+						},
+						{
+							label: "Prompts",
+							value: data.prompts
+						},
+						{
+							label: "Records",
+							value: data.records
+						},
+						{
+							label: "Executions",
+							value: data.executions
+						}
+					] }));
+					setSuccess(true);
+					setLoading(false);
+				} catch (err) {
+					setError(err instanceof Error ? err : new Error(String(err)));
+					setSuccess(false);
+					setLoading(false);
+				}
+			};
+			run();
+		}, []);
+		return React.createElement(MutationResult, {
+			loading,
+			loadingLabel: "Fetching stats...",
+			success,
+			successMessage: "Account Statistics",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+analyticsCommand.command("results").description("List execution results").option("--flow <id>", "Filter by flow ID").option("--record <id>", "Filter by record ID").option("--status <status>", "Filter by status").option("--limit <n>", "Limit results", "20").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	const params = { limit: options.limit };
+	if (options.flow) params.flowId = options.flow;
+	if (options.record) params.recordId = options.record;
+	if (options.status) params.status = options.status;
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.get("/analytics/record-results", params);
+			if (options.json) printJson(data);
+			else {
+				const results = data.data ?? [];
+				if (results.length === 0) {
+					console.log(chalk.gray("No results found"));
+					return;
+				}
+				console.log(chalk.cyan("Execution Results:"));
+				for (const result of results) {
+					const statusColor = result.status === "completed" ? "green" : "red";
+					const date = result.createdAt ? chalk.gray(` ${result.createdAt}`) : "";
+					console.log(`  ${chalk.green(result.id)} ${chalk[statusColor](`[${result.status}]`)} flow=${chalk.gray(result.flowId)} record=${chalk.gray(result.recordId)}${date}`);
+				}
+				const total = getTotalCount(data.pagination);
+				if (total !== void 0) console.log(chalk.dim(`\n  Total: ${total} results`));
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to fetch results"));
+			console.error(chalk.red(message));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [items, setItems] = useState(null);
+		const [total, setTotal] = useState(void 0);
+		const [error, setError] = useState(null);
+		useEffect(() => {
+			const run = async () => {
+				try {
+					const data = await client.get("/analytics/record-results", params);
+					setItems(data.data ?? []);
+					setTotal(getTotalCount(data.pagination));
+					setLoading(false);
+				} catch (err) {
+					setError(err instanceof Error ? err : new Error(String(err)));
+					setLoading(false);
+				}
+			};
+			run();
+		}, []);
+		return React.createElement(DataList, {
+			title: "Execution Results",
+			items,
+			error,
+			loading,
+			total,
+			emptyMessage: "No results found",
+			renderCard: (item) => {
+				const r = item;
+				const statusColor = r.status === "completed" ? "green" : "red";
+				return React.createElement(Text, { color: statusColor }, `  ${r.id} [${r.status}] flow=${r.flowId} record=${r.recordId}${r.createdAt ? ` ${r.createdAt}` : ""}`);
+			}
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+export { analyticsCommand };
+