@runtypelabs/cli 2.59.1 → 2.59.2

package/dist/chunk-DFj1UPB2.js

@@ -0,0 +1,330 @@
+#!/usr/bin/env node
+import { t as isTTY } from "./index.js";
+import { ConfirmPrompt, DataList, EntityCard, MutationResult, React, 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, n as buildListParams, s as printNextCursorHint } from "./chunk-CcFCyqbB.js";
+import { n as renderMessageContentWithImages, r as detectImageProtocol, t as renderMessageContent } from "./chunk-CW6AzBH6.js";
+import { Command } from "commander";
+import chalk from "chalk";
+// src/commands/conversations.ts
+const TOOL_RESULT_PREVIEW_CHARS = 200;
+/** One line per tool call or result a message carries, so a tool turn never prints as a blank line. */
+function renderToolActivity(msg) {
+	const calls = (msg.toolCalls ?? []).map((call) => `-> ${call.toolName}(${JSON.stringify(call.args ?? {})})`);
+	const results = (msg.toolResults ?? []).map((result) => {
+		const text = JSON.stringify(result.result ?? null) ?? "null";
+		const preview = text.length > TOOL_RESULT_PREVIEW_CHARS ? `${text.slice(0, 199)}…` : text;
+		return `<- ${result.toolName}: ${preview}`;
+	});
+	return [...calls, ...results];
+}
+/**
+* Write one message line, emitting inline image escape sequences for renderable
+* image parts and falling back to the text marker (via {@link renderMessageContent})
+* for everything else. Used only on the interactive, image-capable path; the
+* images are written on their own lines below the text so they don't interleave.
+*/
+function writeMessageWithImages(msg, rolePrefix, protocol) {
+	const out = process.stdout;
+	const { text, images } = renderMessageContentWithImages(msg.content, protocol);
+	out.write(`${rolePrefix}${text}\n`);
+	for (const seq of images) out.write(`${seq}\n`);
+}
+/**
+* Print a conversation's detail + messages to stdout (the non-Ink path). When
+* `imageProtocol` is set (interactive, image-capable terminal), image parts are
+* rendered inline; otherwise every part collapses to a text marker.
+*/
+function printConversationDetail(data, imageProtocol) {
+	printDetail("Conversation", [
+		{
+			label: "ID",
+			value: data.id
+		},
+		{
+			label: "Title",
+			value: data.title
+		},
+		{
+			label: "Model",
+			value: data.modelId
+		},
+		{
+			label: "System prompt",
+			value: data.systemPrompt
+		},
+		{
+			label: "Owner",
+			value: data.ownerId
+		},
+		{
+			label: "Source",
+			value: data.source
+		},
+		{
+			label: "Created",
+			value: data.createdAt
+		},
+		{
+			label: "Updated",
+			value: data.updatedAt
+		}
+	]);
+	const messages = data.messages ?? [];
+	console.log(chalk.cyan(`\nMessages (${messages.length}):`));
+	if (messages.length === 0) {
+		console.log(chalk.gray("  No messages"));
+		return;
+	}
+	for (const msg of messages) {
+		const roleColor = msg.role === "user" ? chalk.blue : msg.role === "assistant" ? chalk.green : chalk.gray;
+		if (imageProtocol) writeMessageWithImages(msg, `  ${roleColor(msg.role)}: `, imageProtocol);
+		else console.log(`  ${roleColor(msg.role)}: ${renderMessageContent(msg.content)}`);
+		for (const line of renderToolActivity(msg)) console.log(chalk.gray(`    ${line}`));
+		if (msg.createdAt) console.log(chalk.dim(`    ${msg.createdAt}`));
+	}
+}
+const conversationsCommand = new Command("conversations").description("Manage conversations");
+conversationsCommand.command("list").description("List your conversations").option("--owner-id <id>", "Filter by owner key (the indexed owner_id column)").option("--limit <n>", "Limit results (defaults to the API page size)").option("--cursor <cursor>", "Pagination cursor for the next page").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 = buildListParams(options, { ownerId: options.ownerId });
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.get("/conversations", params);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			const conversations = data.conversations ?? [];
+			if (conversations.length === 0) {
+				console.log("No conversations found");
+				return;
+			}
+			console.log("Your Conversations:");
+			for (const conv of conversations) {
+				const count = conv.messageCount ?? 0;
+				const sourceTag = conv.source ? ` [${conv.source}]` : "";
+				console.log(`  ${chalk.green(conv.id)} ${conv.title}${sourceTag}`);
+				console.log(`    Messages: ${count}`);
+				if (conv.updatedAt) console.log(`    Updated: ${conv.updatedAt}`);
+			}
+			console.log(chalk.dim(`\n  Showing ${conversations.length} conversations`));
+			printNextCursorHint("runtype conversations list", data.pagination);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to fetch conversations: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [items, setItems] = useState(null);
+		const [error, setError] = useState(null);
+		const [total, setTotal] = useState();
+		useEffect(() => {
+			client.get("/conversations", params).then((res) => {
+				const conversations = res.conversations ?? [];
+				setItems(conversations);
+				setTotal(conversations.length);
+			}).catch((err) => setError(err instanceof Error ? err : new Error(String(err))));
+		}, []);
+		return React.createElement(DataList, {
+			title: "Your Conversations",
+			items,
+			error,
+			loading: items === null && error === null,
+			total,
+			emptyMessage: "No conversations found",
+			renderCard: (item) => {
+				const conv = item;
+				return React.createElement(EntityCard, { fields: [
+					{
+						label: "ID",
+						value: conv.id,
+						color: "green"
+					},
+					{
+						label: "Title",
+						value: conv.title
+					},
+					{
+						label: "Source",
+						value: conv.source,
+						color: "gray"
+					},
+					{
+						label: "Messages",
+						value: conv.messageCount !== void 0 ? String(conv.messageCount) : void 0,
+						color: "gray"
+					},
+					{
+						label: "Updated",
+						value: conv.updatedAt
+					}
+				] });
+			}
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+conversationsCommand.command("get <id>").description("Get conversation details including its messages").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").option("--no-images", "Disable inline image rendering even in supported terminals").action(async (id, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	const interactive = isTTY(options) && !options.json;
+	const imageProtocol = interactive && options.images !== false ? detectImageProtocol() : null;
+	if (!interactive || imageProtocol) {
+		try {
+			const data = await client.get(`/conversations/${id}`);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			printConversationDetail(data, imageProtocol);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to fetch conversation: ${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(`/conversations/${id}`);
+					const messages = data.messages ?? [];
+					const messageSummary = messages.length === 0 ? "No messages" : messages.map((m) => [`${m.role}: ${renderMessageContent(m.content)}`, ...renderToolActivity(m)].join("\n  ")).join("\n");
+					setResultNode(React.createElement(EntityCard, { fields: [
+						{
+							label: "ID",
+							value: data.id,
+							color: "green"
+						},
+						{
+							label: "Title",
+							value: data.title
+						},
+						{
+							label: "Model",
+							value: data.modelId
+						},
+						{
+							label: "System prompt",
+							value: data.systemPrompt
+						},
+						{
+							label: "Owner",
+							value: data.ownerId
+						},
+						{
+							label: "Source",
+							value: data.source,
+							color: "gray"
+						},
+						{
+							label: "Created",
+							value: data.createdAt
+						},
+						{
+							label: "Updated",
+							value: data.updatedAt
+						},
+						{
+							label: `Messages (${messages.length})`,
+							value: messageSummary
+						}
+					] }));
+					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 conversation...",
+			success,
+			successMessage: "Conversation",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+conversationsCommand.command("delete <id>").description("Delete a conversation").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").option("--yes", "Skip confirmation").action(async (id, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	if (!isTTY(options)) {
+		try {
+			await client.conversations.delete(id);
+			console.log(JSON.stringify({
+				status: "deleted",
+				id
+			}, null, 2));
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to delete conversation: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const runDelete = () => {
+		const App = () => {
+			const [loading, setLoading] = useState(true);
+			const [success, setSuccess] = useState(null);
+			const [error, setError] = useState(null);
+			useEffect(() => {
+				client.delete(`/conversations/${id}`).then(() => {
+					setSuccess(true);
+					setLoading(false);
+				}).catch((err) => {
+					setError(err instanceof Error ? err : new Error(String(err)));
+					setSuccess(false);
+					setLoading(false);
+				});
+			}, []);
+			return React.createElement(MutationResult, {
+				loading,
+				loadingLabel: "Deleting conversation...",
+				success,
+				successMessage: "Conversation deleted",
+				error
+			});
+		};
+		return App;
+	};
+	if (options.yes) {
+		const { waitUntilExit } = render(React.createElement(runDelete()));
+		await waitUntilExit();
+		return;
+	}
+	if (!await new Promise((resolve) => {
+		const { unmount } = render(React.createElement(ConfirmPrompt, {
+			message: `Delete conversation ${id}?`,
+			defaultValue: false,
+			onConfirm: (result) => {
+				resolve(result);
+				unmount();
+			}
+		}));
+	})) return;
+	const { waitUntilExit } = render(React.createElement(runDelete()));
+	await waitUntilExit();
+});
+export { conversationsCommand };
+

package/dist/chunk-DGdFdZVf.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+import { c as TRACE_QUERY_DIMENSIONS, l as TRACE_SLICE_SPAN_KINDS } from "./chunk-ucu5lrDZ.js";
+import { r as createCliClient } from "./chunk-BW2fg46T.js";
+import { n as ensureAuth } from "./chunk-CJraEBVd.js";
+import { a as printJson } from "./chunk-CcFCyqbB.js";
+import { Command } from "commander";
+import chalk from "chalk";
+// src/commands/traces.ts
+const tracesCommand = new Command("traces").description("Mine traces: aggregate runs, read a bounded slice of one trace, compare two runs or cohorts");
+async function run(json, action, render) {
+	try {
+		const apiKey = await ensureAuth();
+		if (!apiKey) return;
+		const result = await action(createCliClient(apiKey));
+		if (json) printJson(result);
+		else for (const line of render(result)) console.log(line);
+	} catch (error) {
+		console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+		process.exitCode = 1;
+	}
+}
+function integer(value) {
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed < 0) throw new Error(`Expected a non-negative integer, got "${value}"`);
+	return parsed;
+}
+function list(value) {
+	if (value === void 0) return void 0;
+	const items = value.split(",").map((item) => item.trim()).filter(Boolean);
+	return items.length > 0 ? items : void 0;
+}
+function oneOf(value, allowed, flag) {
+	if (allowed.includes(value)) return value;
+	throw new Error(`${flag} accepts ${allowed.join(", ")}; got "${value}"`);
+}
+function buildFilters(options) {
+	const agentIds = list(options.agent);
+	const agentVersionIds = list(options.agentVersion);
+	const flowIds = list(options.flow);
+	return {
+		...agentIds ? { agentIds } : {},
+		...agentVersionIds ? { agentVersionIds } : {},
+		...flowIds ? { flowIds } : {},
+		...options.surface ? { surfaceId: options.surface } : {},
+		...options.model ? { model: options.model } : {},
+		...options.source ? { source: oneOf(options.source, ["hosted", "ingested"], "--source") } : {},
+		...options.status ? { status: oneOf(options.status, [
+			"running",
+			"completed",
+			"failed"
+		], "--status") } : {},
+		...options.stopReason ? { stopReason: options.stopReason } : {},
+		...options.signal ? { signal: options.signal } : {},
+		...options.from ? { from: options.from } : {},
+		...options.to ? { to: options.to } : {},
+		...options.includeChildren ? { includeChildren: true } : {}
+	};
+}
+function buildTraceQueryRequest(options) {
+	const groupBy = list(options.groupBy)?.map((dimension) => oneOf(dimension, TRACE_QUERY_DIMENSIONS, "--group-by"));
+	if (groupBy && groupBy.length > 2) throw new Error("--group-by takes at most two dimensions");
+	return {
+		...buildFilters(options),
+		...groupBy ? { groupBy } : {},
+		...options.signalRate ? { signalRate: options.signalRate } : {},
+		...options.includeToolCalls ? { includeToolCalls: true } : {},
+		...options.limit !== void 0 ? { limit: options.limit } : {},
+		...options.cursor ? { cursor: options.cursor } : {}
+	};
+}
+function buildTraceSliceParams(options) {
+	if (options.aroundFirstFailure !== void 0 && (options.start !== void 0 || options.end !== void 0)) throw new Error("--around-first-failure does not combine with --start/--end");
+	return {
+		...options.start !== void 0 ? { start: options.start } : {},
+		...options.end !== void 0 ? { end: options.end } : {},
+		...options.kind ? { kind: oneOf(options.kind, TRACE_SLICE_SPAN_KINDS, "--kind") } : {},
+		...options.tool ? { toolName: options.tool } : {},
+		...options.aroundFirstFailure !== void 0 ? { aroundFirstFailure: options.aroundFirstFailure } : {},
+		...options.limit !== void 0 ? { limit: options.limit } : {},
+		...options.includeContent ? { includeContent: true } : {},
+		...options.maxContentBytes !== void 0 ? { maxContentBytes: options.maxContentBytes } : {}
+	};
+}
+function compareSide(name, executionId, filters) {
+	if (executionId && filters) throw new Error(`Pass --${name} or --${name}-filters, not both`);
+	if (executionId) return { executionId };
+	if (!filters) throw new Error(`Pass --${name} <executionId> or --${name}-filters '<json>'`);
+	let parsed;
+	try {
+		parsed = JSON.parse(filters);
+	} catch {
+		throw new Error(`--${name}-filters is not valid JSON`);
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error(`--${name}-filters must be a JSON object of trace filters`);
+	return { filters: parsed };
+}
+function buildTraceCompareRequest(options) {
+	return {
+		left: compareSide("left", options.left, options.leftFilters),
+		right: compareSide("right", options.right, options.rightFilters),
+		...options.from ? { from: options.from } : {},
+		...options.to ? { to: options.to } : {},
+		...options.sampleSize !== void 0 ? { sampleSize: options.sampleSize } : {}
+	};
+}
+function pct(value) {
+	return value === null || value === void 0 ? "-" : `${(value * 100).toFixed(1)}%`;
+}
+function num(value) {
+	if (value === null || value === void 0) return "-";
+	return Number.isInteger(value) ? String(value) : value.toFixed(4);
+}
+function metricsLine(metrics) {
+	const parts = [
+		`runs ${metrics.count}`,
+		`failed ${metrics.failed} (${pct(metrics.failureRate)})`,
+		`tokens p50 ${num(metrics.tokens.p50)}`,
+		`cost ${num(metrics.cost.sum)}${metrics.cost.unpricedRuns > 0 ? ` (+${metrics.cost.unpricedRuns} unpriced)` : ""}`,
+		`duration p50/p95 ${num(metrics.durationMs.p50)}/${num(metrics.durationMs.p95)}ms`
+	];
+	if (metrics.toolCalls) parts.push(`tool calls p50/p95 ${num(metrics.toolCalls.p50)}/${num(metrics.toolCalls.p95)}`);
+	if (metrics.signalRate) parts.push(`signal uniform ${pct(metrics.signalRate.uniform.rate)} (${metrics.signalRate.uniform.evaluated}), filtered ${pct(metrics.signalRate.filtered.rate)} (${metrics.signalRate.filtered.evaluated})`);
+	return parts.join(" · ");
+}
+function formatTraceQuery(result) {
+	const lines = [chalk.cyan(`Traces ${result.window.from} → ${result.window.to}`)];
+	for (const warning of result.warnings) lines.push(chalk.yellow(`  Warning (${warning.code}): ${warning.message}`));
+	if (result.groupBy.length > 0) {
+		if (result.groups.length === 0) lines.push(chalk.gray("  No runs matched"));
+		for (const group of result.groups) {
+			const key = result.groupBy.map((dimension) => `${dimension}=${group.key[dimension] ?? "(none)"}`).join(" ");
+			lines.push(`  ${chalk.bold(key)}`);
+			lines.push(`    ${metricsLine(group)}`);
+			if (group.sampleExecutionIds.length > 0) lines.push(chalk.dim(`    samples: ${group.sampleExecutionIds.join(", ")}`));
+		}
+	}
+	lines.push(`  ${chalk.bold("Total")}  ${metricsLine(result.totals)}`);
+	if (result.nextCursor) lines.push(chalk.yellow("\n  More groups available — fetch the next page with:") + chalk.dim(`\n    runtype traces query ... --cursor ${result.nextCursor}`));
+	return lines;
+}
+function formatTraceSlice(slice) {
+	const { selection } = slice;
+	const lines = [chalk.cyan(`Trace ${slice.executionId} (${slice.source})`), chalk.dim(`  spans ${selection.from}-${selection.to} of ${slice.totalSpans} (${slice.matchedSpans} matched, ${selection.mode}${selection.firstFailedIndex !== null ? `, first failure at #${selection.firstFailedIndex}` : ""})`)];
+	for (const span of slice.spans) {
+		const status = span.status === "error" || span.error ? chalk.red(span.status) : chalk.green(span.status);
+		const label = span.toolName ? `${span.name} [${span.toolName}]` : span.name;
+		const detail = [
+			span.kind,
+			span.model,
+			span.durationMs !== null ? `${span.durationMs}ms` : null,
+			span.stopReason ? `stop=${span.stopReason}` : null
+		].filter(Boolean);
+		lines.push(`  #${span.index} ${status} ${label}${detail.length > 0 ? chalk.dim(` (${detail.join(", ")})`) : ""}`);
+		if (span.error) lines.push(chalk.red(`      error: ${span.error}`));
+		if (span.inputPreview) lines.push(chalk.dim(`      in:  ${span.inputPreview}`));
+		if (span.outputPreview) lines.push(chalk.dim(`      out: ${span.outputPreview}`));
+		for (const [field, value] of Object.entries(span.content ?? {})) {
+			if (value === null || value === void 0) continue;
+			const cut = slice.content.cut.some((entry) => entry.spanId === span.spanId && entry.field === field);
+			const text = typeof value === "string" ? value : JSON.stringify(value, null, 2);
+			lines.push(`      ${field}${cut ? chalk.yellow(" (cut)") : ""}:`);
+			for (const line of text.split("\n")) lines.push(`        ${line}`);
+		}
+	}
+	if (slice.truncated) lines.push(chalk.yellow("  More spans matched than were returned; raise --limit or narrow the range"));
+	if (slice.traceTruncated) lines.push(chalk.yellow("  The trace exceeded the span read ceiling"));
+	if (slice.content.loaded) lines.push(chalk.dim(`  content ${slice.content.usedBytes}/${slice.content.limitBytes} bytes, ${slice.content.cut.length} cut`));
+	return lines;
+}
+function formatTraceCompare(compare) {
+	if (compare.mode === "executions") {
+		const side = (label, totals) => `  ${label} ${totals.executionId}: status ${totals.status ?? "-"}, stop ${totals.stopReason ?? "-"}, tool calls ${totals.toolCalls}, cost ${num(totals.cost)}, ${num(totals.durationMs)}ms`;
+		const lines = [
+			chalk.cyan("Execution comparison"),
+			side("left ", compare.left),
+			side("right", compare.right)
+		];
+		const truncatedSides = ["left", "right"].filter((name) => compare.truncated[name]);
+		if (truncatedSides.length > 0) lines.push(chalk.yellow(`  Only the first tool calls were compared on the ${truncatedSides.join(" and ")} side; later calls are not aligned`));
+		lines.push(compare.divergence ? chalk.yellow(`  First divergence at step ${compare.divergence.alignmentIndex}: ${compare.divergence.description}`) : chalk.green("  Tool-call sequences align"));
+		for (const tool of compare.perTool) lines.push(`  ${tool.tool}: calls ${tool.leftCalls} → ${tool.rightCalls}, errors ${tool.leftErrors} → ${tool.rightErrors}` + (tool.argDrift !== null ? `, arg drift ${num(tool.argDrift)}` : ""));
+		return lines;
+	}
+	const side = (label, cohort) => `  ${label} sampled ${cohort.sampled}/${cohort.sampleLimit}, failure ${pct(cohort.failureRate)}`;
+	const lines = [
+		chalk.cyan(`Cohort comparison ${compare.window.from} → ${compare.window.to}`),
+		side("left ", compare.left),
+		side("right", compare.right)
+	];
+	for (const delta of compare.toolShareDelta) lines.push(`  ${delta.tool}: share of runs ${pct(delta.left)} → ${pct(delta.right)} (${delta.delta >= 0 ? "+" : ""}${pct(delta.delta)})`);
+	return lines;
+}
+tracesCommand.command("query").description("Aggregate runs by up to two dimensions, with sample execution ids per group").option("--agent <ids>", "Comma-separated agent ids").option("--agent-version <ids>", "Comma-separated agent version ids (ingested runs only)").option("--flow <ids>", "Comma-separated flow ids").option("--surface <id>", "Surface id").option("--model <model>", "Runs with any call to this model (window capped at 7 days)").option("--source <source>", "hosted or ingested").option("--status <status>", "running, completed or failed").option("--stop-reason <reason>", "Only runs that stopped for this reason").option("--signal <signal>", "Only runs where a signal fired: key, or key:value").option("--signal-rate <signal>", "Report the fire rate of this signal per group").option("--group-by <dimensions>", `One or two of: ${TRACE_QUERY_DIMENSIONS.join(", ")}`).option("--from <iso>", "Window start (default: 7 days before --to)").option("--to <iso>", "Window end (default: now)").option("--include-children", "Count subagent and nested-flow runs too").option("--include-tool-calls", "Tool-call percentiles per group (window capped at 7 days)").option("--limit <n>", "Groups per page", integer).option("--cursor <cursor>", "Continue from a previous page").option("--json", "Output as JSON").action((options) => run(options.json, (client) => client.logs.queryTraces(buildTraceQueryRequest(options)), (res) => formatTraceQuery(res.data)));
+tracesCommand.command("slice <executionId>").description("Read a bounded window of one trace (previews only unless --include-content)").option("--start <n>", "First span index to include", integer).option("--end <n>", "Span index to stop before", integer).option("--kind <kind>", `Only spans of this kind: ${TRACE_SLICE_SPAN_KINDS.join(", ")}`).option("--tool <name>", "Only spans of this tool").option("--around-first-failure <n>", "The first failed span plus n spans either side (0-50)", integer).option("--limit <n>", "Spans to return (default 25, max 100)", integer).option("--include-content", "Load full content for the selected spans under the byte budget").option("--max-content-bytes <n>", "Content byte budget (default 65536)", integer).option("--json", "Output as JSON").action((executionId, options) => run(options.json, (client) => client.logs.readTraceSlice(executionId, buildTraceSliceParams(options)), (res) => formatTraceSlice(res.data)));
+tracesCommand.command("compare").description("Compare two executions, or two cohorts of runs selected by filters").option("--left <executionId>", "Left execution").option("--right <executionId>", "Right execution").option("--left-filters <json>", "Left cohort filters, e.g. '{\"agentIds\":[\"agt_1\"],\"status\":\"failed\"}'").option("--right-filters <json>", "Right cohort filters").option("--from <iso>", "Cohort window start").option("--to <iso>", "Cohort window end").option("--sample-size <n>", "Runs sampled per cohort (default 20, max 50)", integer).option("--json", "Output as JSON").action((options) => run(options.json, async (client) => client.logs.compareTrace(buildTraceCompareRequest(options)), (res) => formatTraceCompare(res.data)));
+export { tracesCommand };
+

package/dist/chunk-DGv7X9S_.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import chalk from "chalk";
+import { readFileSync } from "fs";
+// src/lib/file-utils.ts
+/** Parse a string as a JSON object, exiting with a clear error on failure. */
+function parseJsonObject(raw, label) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		console.error(chalk.red(`Invalid JSON in ${label}`));
+		process.exit(1);
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+		console.error(chalk.red(`${label} must be a JSON object`));
+		process.exit(1);
+	}
+	return parsed;
+}
+/**
+* Read and parse a JSON object from a file or `-` for stdin, exiting with a clear error on
+* failure. When `unwrapKey` is provided and present as a nested object, returns
+* that nested object (e.g. an exported `{ "agent": { ... } }` envelope).
+*/
+function readJsonFile(path, opts = {}) {
+	const label = opts.label ?? "file";
+	if (path === "-" && process.stdin.isTTY) {
+		console.error(chalk.red(`Pipe a JSON object into stdin for ${label}, or provide a file path`));
+		process.exit(1);
+	}
+	let raw;
+	try {
+		raw = readFileSync(path === "-" ? 0 : path, "utf-8");
+	} catch {
+		console.error(chalk.red(`Failed to read ${label}: ${path}`));
+		process.exit(1);
+	}
+	const obj = parseJsonObject(raw, label);
+	if (opts.unwrapKey) {
+		const nested = obj[opts.unwrapKey];
+		if (nested && typeof nested === "object" && !Array.isArray(nested)) return { ...nested };
+	}
+	return obj;
+}
+/**
+* Resolve a JSON object payload from exactly one of an inline JSON string or a
+* file path. Exits with a clear error if both or neither are provided, or if the
+* resolved content is not a JSON object.
+*/
+function resolveJsonPayload(inline, fromFile, label) {
+	if (inline !== void 0 && fromFile !== void 0) {
+		console.error(chalk.red(`Error: provide only one of inline JSON or --from-file for ${label}`));
+		process.exit(1);
+	}
+	if (inline === void 0 && fromFile === void 0) {
+		console.error(chalk.red(`Error: ${label} is required — pass inline JSON or --from-file <path>`));
+		process.exit(1);
+	}
+	if (fromFile !== void 0) return readJsonFile(fromFile, { label });
+	return parseJsonObject(inline, label);
+}
+export { resolveJsonPayload as n, readJsonFile as t };
+