@runtypelabs/cli 2.59.1 → 2.59.4

package/dist/chunk-DajZ9Eg4.js

@@ -0,0 +1,299 @@
+#!/usr/bin/env node
+import { t as isTTY } from "./index.js";
+import { 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, s as printNextCursorHint } from "./chunk-CcFCyqbB.js";
+import { Command } from "commander";
+import chalk from "chalk";
+// src/commands/logs.ts
+/** The API's own sentence for a store refusal; both log commands answer on it. */
+const STORE_UNAVAILABLE_MESSAGE = "Log store temporarily unavailable";
+/**
+* Report the store's refusal in the caller's own terms, or answer false so the
+* caller prints its generic failure. The store is the only tier, so a refusal
+* is an error rather than a short answer.
+*/
+function reportStoreUnavailable(message, subject) {
+	if (!message.includes(STORE_UNAVAILABLE_MESSAGE)) return false;
+	console.error(chalk.red(`The log store is temporarily unavailable. No ${subject} could be read; retry shortly.`));
+	return true;
+}
+/** The rendered date counts begin on, or null when the window starts inside coverage. */
+function countsStartAfter(coveredFrom, from) {
+	if (!coveredFrom) return null;
+	const covered = Date.parse(coveredFrom);
+	if (!Number.isFinite(covered)) return null;
+	if (from !== void 0 && covered <= Date.parse(from)) return null;
+	return new Date(covered).toISOString();
+}
+function filterParams(options) {
+	return {
+		from: options.from,
+		to: options.to,
+		level: options.level,
+		category: options.category,
+		flowId: options.flow,
+		agentId: options.agent,
+		executionId: options.execution,
+		surfaceId: options.surface,
+		conversationId: options.conversation,
+		status: options.status,
+		type: options.type
+	};
+}
+function levelColor(level) {
+	switch (level) {
+		case "error": return chalk.red;
+		case "warn": return chalk.yellow;
+		case "debug": return chalk.gray;
+		default: return chalk.cyan;
+	}
+}
+const logsCommand = new Command("logs").description("Query historical logs and aggregate stats (use `tail` for live streaming)");
+logsCommand.command("list").description("Query persisted logs with filtering, search, and pagination").option("--from <iso>", "Start timestamp (ISO 8601, default: 24 hours ago)").option("--to <iso>", "End timestamp (ISO 8601, default: now)").option("--level <levels>", "Comma-separated log levels (debug,info,warn,error)").option("--category <categories>", "Comma-separated categories (execution,agent,tool,...)").option("--flow <id>", "Filter by flow ID").option("--agent <id>", "Filter by agent ID").option("--execution <id>", "Filter by execution ID").option("--surface <id>", "Filter by surface ID").option("--conversation <id>", "Filter by conversation ID").option("--status <statuses>", "Comma-separated statuses (completed,failed,unknown,...)").option("--type <types>", "Comma-separated entry types (flow,step,tool,agent,model,...)").option("--search <text>", "Substring search over a span's message, name, operation, tool name or error class").option("--limit <n>", "Max results per page (default 500, max 1000)").option("--cursor <cursor>", "Pagination cursor from a previous page").option("--order <order>", "Sort order: asc or desc (default desc)").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 = {
+		...filterParams(options),
+		search: options.search,
+		limit: options.limit,
+		cursor: options.cursor,
+		order: options.order
+	};
+	if (!isTTY(options) || options.json) {
+		try {
+			const res = await client.get("/logs", params);
+			if (options.json) {
+				printJson(res);
+				return;
+			}
+			if (res.data?.live?.served === false && res.data.live.reason === "hot_tier_failed") console.error(chalk.yellow("Warning: entries from the last few minutes could not be loaded"));
+			if (res.data?.pagination?.cursorReset) console.error(chalk.yellow("Warning: the cursor was rejected and this is page one again. Do not re-follow it."));
+			const entries = res.data?.entries ?? [];
+			if (entries.length === 0) {
+				console.log(chalk.gray("No logs found"));
+				return;
+			}
+			console.log(chalk.cyan("Logs:"));
+			for (const entry of entries) {
+				const color = levelColor(entry.level);
+				const level = (entry.level ?? "info").toUpperCase().padEnd(5);
+				const ts = entry.timestamp ?? "";
+				const cat = entry.category ? chalk.dim(`[${entry.category}]`) : "";
+				console.log(`  ${chalk.dim(ts)} ${color(level)} ${cat} ${entry.message ?? ""}`);
+				const ids = [
+					entry.executionId ? `exec=${entry.executionId}` : null,
+					entry.flowId ? `flow=${entry.flowId}` : null,
+					entry.agentId ? `agent=${entry.agentId}` : null,
+					entry.surfaceId ? `surface=${entry.surfaceId}` : null,
+					entry.conversationId ? `conv=${entry.conversationId}` : null
+				].filter(Boolean);
+				if (ids.length > 0) console.log(chalk.dim(`    ${ids.join(" ")}`));
+			}
+			console.log(chalk.dim(`\n  Total: ${entries.length} entries`));
+			if (!res.data?.pagination?.cursorReset) printNextCursorHint("runtype logs list", res.data?.pagination);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			if (reportStoreUnavailable(message, "entries")) {
+				process.exitCode = 1;
+				return;
+			}
+			console.error(chalk.red(`Failed to query logs: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [items, setItems] = useState(null);
+		const [error, setError] = useState(null);
+		const [total, setTotal] = useState();
+		useEffect(() => {
+			client.get("/logs", params).then((res) => {
+				const entries = res.data?.entries ?? [];
+				setItems(entries);
+				setTotal(entries.length);
+			}).catch((err) => setError(err instanceof Error ? err : new Error(String(err))));
+		}, []);
+		return React.createElement(DataList, {
+			title: "Logs",
+			items,
+			error,
+			loading: items === null && error === null,
+			total,
+			emptyMessage: "No logs found",
+			renderCard: (item) => {
+				const entry = item;
+				return React.createElement(EntityCard, { fields: [
+					{
+						label: "Time",
+						value: entry.timestamp,
+						color: "gray"
+					},
+					{
+						label: "Level",
+						value: entry.level
+					},
+					{
+						label: "Category",
+						value: entry.category,
+						color: "gray"
+					},
+					{
+						label: "Message",
+						value: entry.message
+					},
+					{
+						label: "Execution",
+						value: entry.executionId,
+						color: "gray"
+					},
+					{
+						label: "Flow",
+						value: entry.flowId,
+						color: "gray"
+					},
+					{
+						label: "Agent",
+						value: entry.agentId,
+						color: "gray"
+					},
+					{
+						label: "Surface",
+						value: entry.surfaceId,
+						color: "gray"
+					},
+					{
+						label: "Conversation",
+						value: entry.conversationId,
+						color: "gray"
+					}
+				] });
+			}
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+logsCommand.command("stats").description("Aggregate log stats: totals, counts by level/category, and a histogram").option("--from <iso>", "Start timestamp (ISO 8601, default: 24 hours ago)").option("--to <iso>", "End timestamp (ISO 8601, default: now)").option("--level <levels>", "Comma-separated log levels (debug,info,warn,error)").option("--category <categories>", "Comma-separated categories (execution,agent,tool,...)").option("--flow <id>", "Filter by flow ID").option("--agent <id>", "Filter by agent ID").option("--execution <id>", "Filter by execution ID").option("--surface <id>", "Filter by surface ID").option("--conversation <id>", "Filter by conversation ID").option("--status <statuses>", "Comma-separated statuses (completed,failed,unknown,...)").option("--type <types>", "Comma-separated entry types (flow,step,tool,agent,model,...)").option("--search <text>", "Substring search over a span's message, name, operation, tool name or error class").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 = {
+		...filterParams(options),
+		search: options.search
+	};
+	const formatCounts = (counts) => {
+		const entries = Object.entries(counts);
+		if (entries.length === 0) return "(none)";
+		return entries.map(([k, v]) => `${k}=${v}`).join(", ");
+	};
+	if (!isTTY(options) || options.json) {
+		try {
+			const res = await client.get("/logs/stats", params);
+			if (options.json) {
+				printJson(res);
+				return;
+			}
+			const stats = res.data;
+			if (stats?.degraded) console.error(chalk.yellow("Warning: part of this window could not be read; counts are partial"));
+			const startsLate = countsStartAfter(stats.coveredFrom, params.from);
+			if (startsLate) console.error(chalk.yellow(`Counts start ${startsLate}`));
+			printDetail("Log Stats", [
+				{
+					label: "Total",
+					value: stats.total
+				},
+				{
+					label: "By Level",
+					value: formatCounts(stats.byLevel ?? {})
+				},
+				{
+					label: "By Category",
+					value: formatCounts(stats.byCategory ?? {})
+				},
+				{
+					label: "By Type",
+					value: formatCounts(stats.byType ?? {})
+				},
+				{
+					label: "By Status",
+					value: formatCounts(stats.byStatus ?? {})
+				}
+			]);
+			const histogram = stats.histogram ?? [];
+			console.log(chalk.cyan(`\nHistogram (${histogram.length} buckets):`));
+			if (histogram.length === 0) console.log(chalk.gray("  No data"));
+			else for (const b of histogram) {
+				const errPart = b.errors > 0 ? chalk.red(` (${b.errors} errors)`) : "";
+				console.log(`  ${chalk.dim(b.bucket)}  ${b.count}${errPart}`);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			if (!reportStoreUnavailable(message, "counts")) console.error(chalk.red(`Failed to query log stats: ${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 stats = (await client.get("/logs/stats", params)).data;
+					const histogram = stats.histogram ?? [];
+					const histogramSummary = histogram.length === 0 ? "No data" : histogram.map((b) => `${b.bucket}: ${b.count}${b.errors > 0 ? ` (${b.errors} err)` : ""}`).join("\n");
+					setResultNode(React.createElement(EntityCard, { fields: [
+						{
+							label: "Total",
+							value: String(stats.total)
+						},
+						{
+							label: "By Level",
+							value: formatCounts(stats.byLevel ?? {})
+						},
+						{
+							label: "By Category",
+							value: formatCounts(stats.byCategory ?? {})
+						},
+						{
+							label: "By Type",
+							value: formatCounts(stats.byType ?? {})
+						},
+						{
+							label: "By Status",
+							value: formatCounts(stats.byStatus ?? {})
+						},
+						{
+							label: `Histogram (${histogram.length})`,
+							value: histogramSummary
+						}
+					] }));
+					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 log stats...",
+			success,
+			successMessage: "Log Stats",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+export { logsCommand };
+

package/dist/chunk-Df4dunvU.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+import { i as getApiUrl, r as createCliClient } from "./chunk-BW2fg46T.js";
+import { n as ensureAuth } from "./chunk-CJraEBVd.js";
+import { Command } from "commander";
+import chalk from "chalk";
+// src/commands/tail.ts
+/** Show TypeID prefix + first 4 chars of suffix for compact display. */
+function abbreviateId(id) {
+	const underscoreIdx = id.lastIndexOf("_");
+	if (underscoreIdx === -1) return id.length > 8 ? `${id.slice(0, 8)}...` : id;
+	return `${id.slice(0, underscoreIdx)}_${id.slice(underscoreIdx + 1).slice(0, 4)}...`;
+}
+/** Format a timestamp string to HH:MM:SS.mmm */
+function formatTime(ts) {
+	const d = new Date(ts);
+	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}.${String(d.getMilliseconds()).padStart(3, "0")}`;
+}
+const LEVEL_COLORS = {
+	debug: chalk.gray,
+	info: chalk.blue,
+	warn: chalk.yellow,
+	error: chalk.red
+};
+function levelBadge(level, useColor) {
+	const tag = level.toUpperCase().padEnd(5);
+	if (!useColor) return `[${tag}]`;
+	return (LEVEL_COLORS[level] || chalk.white)(`[${tag}]`);
+}
+function categoryBadge(category, useColor) {
+	if (!useColor) return `[${category}]`;
+	return chalk.magenta(`[${category}]`);
+}
+function formatTailData(data) {
+	return Object.entries(data).map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
+}
+function formatContextIds(event, useColor) {
+	const ids = [];
+	if (event.executionId) ids.push(`exec=${abbreviateId(event.executionId)}`);
+	if (event.flowId) ids.push(`flow=${abbreviateId(event.flowId)}`);
+	if (event.agentId) ids.push(`agent=${abbreviateId(event.agentId)}`);
+	if (event.surfaceId) ids.push(`surface=${abbreviateId(event.surfaceId)}`);
+	if (event.requestId) ids.push(`req=${abbreviateId(event.requestId)}`);
+	if (event.conversationId) ids.push(`conv=${abbreviateId(event.conversationId)}`);
+	if (ids.length === 0) return "";
+	const text = ids.join(" ");
+	return useColor ? chalk.gray(` ${text}`) : ` ${text}`;
+}
+function formatEvent(event, useColor) {
+	const time = useColor ? chalk.gray(formatTime(event.timestamp)) : formatTime(event.timestamp);
+	const level = levelBadge(event.level, useColor);
+	const cat = categoryBadge(event.category, useColor);
+	const ctx = formatContextIds(event, useColor);
+	const data = event.tailData && Object.keys(event.tailData).length > 0 ? useColor ? chalk.gray(` | ${formatTailData(event.tailData)}`) : ` | ${formatTailData(event.tailData)}` : "";
+	return `${time} ${level} ${cat} ${event.message}${data}${ctx}`;
+}
+async function consumeSSEStream(reader, options, signal) {
+	const decoder = new TextDecoder();
+	let buffer = "";
+	const useColor = options.color;
+	while (!signal.aborted) {
+		const { done, value } = await reader.read();
+		if (done) return "eof";
+		buffer += decoder.decode(value, { stream: true });
+		let boundary;
+		while ((boundary = buffer.indexOf("\n\n")) !== -1) {
+			const chunk = buffer.slice(0, boundary);
+			buffer = buffer.slice(boundary + 2);
+			const dataLines = [];
+			for (const line of chunk.split("\n")) if (line.startsWith("data: ")) dataLines.push(line.slice(6));
+			if (dataLines.length === 0) continue;
+			const raw = dataLines.join("\n");
+			let msg;
+			try {
+				msg = JSON.parse(raw);
+			} catch {
+				continue;
+			}
+			switch (msg.type) {
+				case "tail_event":
+					if (options.json) process.stdout.write(JSON.stringify(msg.event) + "\n");
+					else process.stdout.write(formatEvent(msg.event, useColor) + "\n");
+					break;
+				case "tail_gap":
+					process.stderr.write((useColor ? chalk.yellow(`[warn] Dropped ${msg.droppedCount} event(s) between ${msg.fromTimestamp} and ${msg.toTimestamp}`) : `[warn] Dropped ${msg.droppedCount} event(s) between ${msg.fromTimestamp} and ${msg.toTimestamp}`) + "\n");
+					break;
+				case "tail_connected":
+					process.stderr.write((useColor ? chalk.green(`Connected to tail session ${msg.sessionId}`) : `Connected to tail session ${msg.sessionId}`) + "\n");
+					break;
+				case "tail_error": process.stderr.write((useColor ? chalk.red(`[error] ${msg.error}`) : `[error] ${msg.error}`) + "\n");
+			}
+		}
+	}
+	return "aborted";
+}
+async function createSession(apiUrl, apiKey, filters) {
+	const filter = {};
+	const arrayFields = {
+		flowId: "flowIds",
+		agentId: "agentIds",
+		surfaceId: "surfaceIds",
+		executionId: "executionIds",
+		level: "levels",
+		category: "categories"
+	};
+	for (const [k, v] of Object.entries(filters)) if (v !== void 0 && arrayFields[k]) filter[arrayFields[k]] = [v];
+	const body = Object.keys(filter).length > 0 ? { filter } : {};
+	const client = createCliClient(apiKey, apiUrl);
+	try {
+		return await client.post("/tail/sessions", body);
+	} catch (error) {
+		const apiError = error;
+		if (typeof apiError.statusCode === "number") {
+			const statusText = typeof apiError.statusText === "string" ? ` ${apiError.statusText}` : "";
+			const message = typeof apiError.message === "string" && apiError.message ? ` — ${apiError.message}` : "";
+			throw new Error(`Failed to create tail session: ${apiError.statusCode}${statusText}${message}`, { cause: error });
+		}
+		throw error;
+	}
+}
+async function connectAndStream(sseUrl, apiKey, options, signal) {
+	const res = await createCliClient(apiKey).requestStream(sseUrl, {
+		method: "GET",
+		headers: { Accept: "text/event-stream" },
+		signal
+	});
+	if (!res.body) throw new Error("SSE response has no body");
+	const reader = res.body.getReader();
+	try {
+		return await consumeSSEStream(reader, options, signal);
+	} finally {
+		reader.releaseLock();
+	}
+}
+const BASE_DELAY_MS = 1e3;
+const MAX_DELAY_MS = 3e4;
+const MAX_ATTEMPTS = 10;
+async function runTail(options) {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const apiUrl = getApiUrl();
+	const filters = {
+		flowId: options.flow,
+		agentId: options.agent,
+		surfaceId: options.surface,
+		executionId: options.execution,
+		level: options.level,
+		category: options.category
+	};
+	const useColor = options.color;
+	const activeFilters = Object.entries(filters).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}=${v}`);
+	process.stderr.write((useColor ? chalk.gray(`Connecting to ${apiUrl}...${activeFilters.length ? ` filters: ${activeFilters.join(", ")}` : ""}`) : `Connecting to ${apiUrl}...${activeFilters.length ? ` filters: ${activeFilters.join(", ")}` : ""}`) + "\n");
+	const controller = new AbortController();
+	let shuttingDown = false;
+	const shutdown = () => {
+		if (shuttingDown) return;
+		shuttingDown = true;
+		process.stderr.write((useColor ? chalk.gray("\nDisconnecting...") : "\nDisconnecting...") + "\n");
+		controller.abort();
+	};
+	process.on("SIGINT", shutdown);
+	process.on("SIGTERM", shutdown);
+	let attempt = 0;
+	while (!shuttingDown && attempt < MAX_ATTEMPTS) try {
+		const session = await createSession(apiUrl, apiKey, filters);
+		attempt = 0;
+		if (await connectAndStream(session.sseUrl, apiKey, options, controller.signal) === "aborted" || shuttingDown) break;
+		process.stderr.write((useColor ? chalk.yellow("Stream ended, reconnecting...") : "Stream ended, reconnecting...") + "\n");
+	} catch (err) {
+		if (shuttingDown || controller.signal.aborted) break;
+		attempt++;
+		const delay = Math.min(BASE_DELAY_MS * Math.pow(2, attempt - 1), MAX_DELAY_MS);
+		const message = err instanceof Error ? err.message : String(err);
+		process.stderr.write((useColor ? chalk.red(`Connection error: ${message}`) : `Connection error: ${message}`) + "\n");
+		if (attempt >= MAX_ATTEMPTS) {
+			process.stderr.write((useColor ? chalk.red(`Max reconnect attempts (${MAX_ATTEMPTS}) reached. Exiting.`) : `Max reconnect attempts (${MAX_ATTEMPTS}) reached. Exiting.`) + "\n");
+			process.exit(1);
+		}
+		process.stderr.write((useColor ? chalk.gray(`Retrying in ${delay / 1e3}s (attempt ${attempt}/${MAX_ATTEMPTS})...`) : `Retrying in ${delay / 1e3}s (attempt ${attempt}/${MAX_ATTEMPTS})...`) + "\n");
+		await new Promise((resolve) => {
+			const timer = setTimeout(resolve, delay);
+			const onAbort = () => {
+				clearTimeout(timer);
+				resolve();
+			};
+			controller.signal.addEventListener("abort", onAbort, { once: true });
+		});
+	}
+	process.removeListener("SIGINT", shutdown);
+	process.removeListener("SIGTERM", shutdown);
+}
+const tailCommand = new Command("tail").description("Stream live execution logs from the Runtype API").option("--flow <id>", "Filter by flow ID").option("--agent <id>", "Filter by agent ID").option("--surface <id>", "Filter by surface ID").option("--execution <id>", "Filter by execution ID").option("--level <level>", "Filter by level (debug/info/warn/error)").option("--category <category>", "Filter by category (execution/agent/tool/model/system/error)").option("--json", "Output raw JSON (one object per line)").option("--no-color", "Disable color output").action(async (options) => {
+	await runTail(options);
+});
+export { tailCommand };
+