@runtypelabs/cli 2.59.0 → 2.59.2

package/dist/chunk-CZrqoPyf.js

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+import { _ as isProductEventName, a as PRODUCT_EVENT_DEFAULT_NEXT_POLL_MS, i as PRODUCT_EVENT_CURSOR_PATTERN, o as PRODUCT_EVENT_MAX_WAIT_MS, s as PRODUCT_EVENT_NAMES } from "./chunk-ucu5lrDZ.js";
+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";
+import { RuntypeApiError } from "@runtypelabs/sdk";
+// src/commands/events.ts
+const LONG_POLL_WAIT_MS = PRODUCT_EVENT_MAX_WAIT_MS;
+const BASE_DELAY_MS = 1e3;
+const MAX_DELAY_MS = 3e4;
+const MAX_ATTEMPTS = 10;
+const MAX_NEXT_POLL_MS = 6e4;
+const MAX_VALUE_CHARS = 120;
+var FatalWatchError = class extends Error {};
+function abortableSleep(ms, signal) {
+	return new Promise((resolve) => {
+		if (signal.aborted) return resolve();
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			resolve();
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+const defaultIo = {
+	stdout: (line) => process.stdout.write(`${line}\n`),
+	stderr: (line) => process.stderr.write(`${line}\n`),
+	sleep: abortableSleep
+};
+/** Parse `--since`: `now` (or omitted) starts at the head; otherwise a decimal cursor. */
+function parseSince(value) {
+	if (value === void 0 || value === "now") return void 0;
+	if (!PRODUCT_EVENT_CURSOR_PATTERN.test(value)) throw new Error(`Invalid --since value "${value}": expected "now" or a decimal cursor`);
+	return value;
+}
+/** Reject an unknown `--name` locally instead of round-tripping to the API's 400. */
+function parseEventName(value) {
+	if (value === void 0 || isProductEventName(value)) return value;
+	throw new Error(`Unknown event type "${value}". Known types: ${PRODUCT_EVENT_NAMES.join(", ")}`);
+}
+/** `--request` filters only this event, and a key with no event scope may read it only by name. */
+const API_KEY_REQUEST_DECIDED_EVENT = "runtype.api_key_request.decided";
+/** Query string for one GET /events call; `after` omitted asks the API for the head cursor. */
+function buildEventsQuery(options, after) {
+	const params = new URLSearchParams();
+	const entries = [
+		["name", options.name ?? (options.request ? API_KEY_REQUEST_DECIDED_EVENT : void 0)],
+		["agentId", options.agent],
+		["flowId", options.flow],
+		["productId", options.product],
+		["surfaceId", options.surface],
+		["scheduleId", options.schedule],
+		["suiteId", options.suite],
+		["simulationId", options.simulation],
+		["taskId", options.task],
+		["requestId", options.request],
+		["key", options.key],
+		["onlyRegressions", options.onlyRegressions ? "true" : void 0],
+		["after", after],
+		["waitMs", after === void 0 ? void 0 : String(LONG_POLL_WAIT_MS)]
+	];
+	for (const [key, value] of entries) if (value !== void 0) params.set(key, value);
+	return params.toString();
+}
+function formatTime(ts) {
+	const d = new Date(ts);
+	if (Number.isNaN(d.getTime())) return 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")}`;
+}
+function formatValue(value) {
+	const singleLine = (typeof value === "string" ? value : JSON.stringify(value)).replace(/\s+/g, " ");
+	return singleLine.length > MAX_VALUE_CHARS ? `${singleLine.slice(0, 117)}...` : singleLine;
+}
+/** One human-readable line per event: local time, name, data fields, cursor. */
+function formatEventLine(event, useColor) {
+	const paint = (fn, s) => useColor ? fn(s) : s;
+	const fields = Object.entries(event.data ?? {}).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${k}=${formatValue(v)}`).join(" ");
+	const time = paint(chalk.gray, formatTime(event.timestamp));
+	const name = paint(event.name.endsWith("failed") ? chalk.red : chalk.cyan, event.name);
+	const cursor = paint(chalk.gray, `#${event.cursor}`);
+	return `${time} ${name}${fields ? ` ${fields}` : ""} ${cursor}`;
+}
+function isFatalApiError(error) {
+	if (!(error instanceof RuntypeApiError)) return false;
+	const status = error.statusCode;
+	return status >= 400 && status < 500 && status !== 408 && status !== 429;
+}
+async function pollOnce(client, options, after, signal) {
+	const body = await (await client.requestStream(`/events?${buildEventsQuery(options, after)}`, {
+		method: "GET",
+		headers: { Accept: "application/json" },
+		signal
+	})).json();
+	if (!body || !Array.isArray(body.events)) throw new FatalWatchError("Unexpected response from GET /events: missing \"events\" array");
+	return {
+		events: body.events,
+		cursor: body.cursor ?? null,
+		truncated: body.truncated === true,
+		hasMore: body.hasMore === true,
+		nextPollMs: typeof body.nextPollMs === "number" ? body.nextPollMs : PRODUCT_EVENT_DEFAULT_NEXT_POLL_MS
+	};
+}
+/**
+* Long-poll GET /events until aborted, printing each event as it arrives.
+* With `json`, stdout carries exactly one ProductEventOccurrence per line; diagnostics go to stderr.
+*/
+async function watchEvents(client, options, signal, io = defaultIo) {
+	const useColor = options.color && !options.json;
+	const warn = (msg) => io.stderr(useColor ? chalk.yellow(msg) : msg);
+	const fail = (msg) => io.stderr(useColor ? chalk.red(msg) : msg);
+	const note = (msg) => io.stderr(useColor ? chalk.gray(msg) : msg);
+	let after = parseSince(options.since);
+	let attempt = 0;
+	while (!signal.aborted) {
+		const longPoll = after !== void 0;
+		let result;
+		try {
+			result = await pollOnce(client, options, after, signal);
+			attempt = 0;
+		} catch (error) {
+			if (signal.aborted) return "aborted";
+			const message = error instanceof Error ? error.message : String(error);
+			if (error instanceof FatalWatchError || isFatalApiError(error)) {
+				fail(`Failed to poll events: ${message}`);
+				return "failed";
+			}
+			attempt++;
+			fail(`Connection error: ${message}`);
+			if (attempt >= MAX_ATTEMPTS) {
+				fail(`Max reconnect attempts (${MAX_ATTEMPTS}) reached. Exiting.`);
+				return "failed";
+			}
+			const delay = Math.min(BASE_DELAY_MS * Math.pow(2, attempt - 1), MAX_DELAY_MS);
+			note(`Retrying in ${delay / 1e3}s (attempt ${attempt}/${MAX_ATTEMPTS})...`);
+			await io.sleep(delay, signal);
+			continue;
+		}
+		if (result.truncated) warn("[warn] Some events were skipped: the cursor was older than the 7-day retention window");
+		for (const event of result.events) io.stdout(options.json ? JSON.stringify(event) : formatEventLine(event, useColor));
+		const lastCursor = result.events.at(-1)?.cursor;
+		after = result.cursor ?? lastCursor ?? after ?? "0";
+		if (options.once && result.events.length > 0) {
+			note(`Resume with --since ${after}`);
+			return "once";
+		}
+		if (result.hasMore || !longPoll) continue;
+		const wait = Math.min(Math.max(result.nextPollMs, 0), MAX_NEXT_POLL_MS);
+		if (wait > 0) await io.sleep(wait, signal);
+	}
+	return "aborted";
+}
+async function runWatch(options) {
+	try {
+		parseSince(options.since);
+		parseEventName(options.name);
+	} catch (error) {
+		process.stderr.write(`${chalk.red(error.message)}\n`);
+		process.exitCode = 1;
+		return;
+	}
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const apiUrl = getApiUrl();
+	const client = createCliClient(apiKey, apiUrl);
+	const useColor = options.color && !options.json;
+	const banner = `Watching ${options.name ?? "all event types"} on ${apiUrl} from ${options.since && options.since !== "now" ? `after cursor ${options.since}` : "now"}...`;
+	process.stderr.write(`${useColor ? chalk.gray(banner) : banner}\n`);
+	const controller = new AbortController();
+	const shutdown = () => {
+		if (controller.signal.aborted) return;
+		process.stderr.write(`${useColor ? chalk.gray("\nDisconnecting...") : "\nDisconnecting..."}\n`);
+		controller.abort();
+	};
+	process.on("SIGINT", shutdown);
+	process.on("SIGTERM", shutdown);
+	try {
+		if (await watchEvents(client, options, controller.signal) === "failed") process.exitCode = 1;
+	} finally {
+		process.removeListener("SIGINT", shutdown);
+		process.removeListener("SIGTERM", shutdown);
+	}
+}
+function filterNames(descriptor) {
+	const properties = descriptor.inputSchema?.properties;
+	return properties && typeof properties === "object" ? Object.keys(properties) : [];
+}
+async function runTypes(options) {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	let events;
+	try {
+		events = (await client.get("/events/types")).events ?? [];
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		process.stderr.write(`${chalk.red(`Failed to list event types: ${message}`)}\n`);
+		process.exitCode = 1;
+		return;
+	}
+	if (options.json) {
+		console.log(JSON.stringify({ events }, null, 2));
+		return;
+	}
+	if (events.length === 0) {
+		console.log(chalk.gray("No event types available"));
+		return;
+	}
+	const width = Math.max(...events.map((e) => e.name.length));
+	console.log(chalk.cyan("Event types:"));
+	for (const event of events) {
+		const name = event.name.padEnd(width);
+		console.log(`  ${options.color ? chalk.green(name) : name}  ${event.description}`);
+		const filters = filterNames(event);
+		if (filters.length > 0) {
+			const line = `  ${" ".repeat(width)}  filters: ${filters.join(", ")}`;
+			console.log(options.color ? chalk.dim(line) : line);
+		}
+	}
+}
+const eventsCommand = new Command("events").description("Watch product events (failed executions, approvals, eval results, ...)");
+eventsCommand.command("types").description("List the product event types you can watch").option("--json", "Output as JSON").option("--no-color", "Disable color output").action(async (options) => {
+	await runTypes(options);
+});
+eventsCommand.command("watch").description("Long-poll product events and print one line per event").option("--name <name>", "Event type to watch (default: every type; see `runtype events types`)").option("--agent <id>", "Filter by agent ID").option("--flow <id>", "Filter by flow ID").option("--product <id>", "Filter by product ID").option("--surface <id>", "Filter by surface ID").option("--schedule <id>", "Filter by schedule ID").option("--suite <id>", "Filter by eval suite ID").option("--simulation <id>", "Filter by simulation ID").option("--task <id>", "Filter by delegated task ID").option("--request <id>", "Filter by API key request ID").option("--key <key>", "Signal events: only this signal key, such as tool_error").option("--only-regressions", "Eval runs: only those whose pass rate dropped").option("--since <cursor>", "Start after this cursor, or \"now\" (default)").option("--json", "Output NDJSON: one event object per line on stdout").option("--once", "Exit after the first poll that returns events").option("--no-color", "Disable color output").action(async (options) => {
+	await runWatch(options);
+});
+export { eventsCommand };
+

package/dist/chunk-CcFCyqbB.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import chalk from "chalk";
+import { RuntypeApiError } from "@runtypelabs/sdk";
+// src/lib/output.ts
+/**
+* Print data as formatted JSON.
+*/
+function printJson(data) {
+	console.log(JSON.stringify(data, null, 2));
+}
+/** The structured `details` list of an API error envelope, for `--json` error output. */
+function apiErrorDetails(error) {
+	if (!(error instanceof RuntypeApiError)) return void 0;
+	const data = error.data;
+	if (typeof data !== "object" || data === null || !("details" in data)) return void 0;
+	return Array.isArray(data.details) && data.details.length > 0 ? data.details : void 0;
+}
+/**
+* Print a list of items with id + name, plus optional extra fields.
+*/
+function printList(items, options) {
+	console.log(chalk.cyan(`${options.title}:`));
+	if (items.length === 0) {
+		console.log(chalk.gray(`  ${options.emptyMessage || "None found"}`));
+		return;
+	}
+	for (const item of items) {
+		const parts = [];
+		for (const col of options.columns) {
+			const value = item[col.key];
+			if (value === void 0 || value === null) continue;
+			const str = String(value);
+			const colorFn = col.color ? chalk[col.color] : (s) => s;
+			if (col.label) parts.push(`${col.label}: ${colorFn(str)}`);
+			else parts.push(colorFn(str));
+		}
+		console.log(`  ${parts.join(" - ")}`);
+	}
+	if (options.total !== void 0) console.log(chalk.dim(`\n  Total: ${options.total}`));
+}
+/**
+* Print a single item's details as key-value pairs.
+*/
+function printDetail(title, fields) {
+	console.log(chalk.cyan(`${title}:`));
+	for (const field of fields) {
+		if (field.value === void 0 || field.value === null) continue;
+		const str = typeof field.value === "object" ? JSON.stringify(field.value) : String(field.value);
+		console.log(`  ${chalk.gray(field.label + ":")} ${str}`);
+	}
+}
+/**
+* Extract total count from a paginated response.
+*/
+function getTotalCount(pagination) {
+	return pagination?.totalCount ?? pagination?.total ?? void 0;
+}
+/**
+* Build query params for a paginated list request from the standard `--limit`/`--cursor`
+* flags, merging in any command-specific filters. Undefined values are omitted.
+*/
+function buildListParams(options, extra) {
+	const params = {};
+	if (options.limit) params.limit = options.limit;
+	if (options.cursor) params.cursor = options.cursor;
+	if (extra) {
+		for (const [key, value] of Object.entries(extra)) if (value !== void 0) params[key] = value;
+	}
+	return params;
+}
+/**
+* Print a hint showing how to fetch the next page via `--cursor`, when more results exist.
+* Normalizes over the `nextCursor`/`cursor` and `hasMore`/`hasNextPage` field variants.
+* `commandPath` is the invocation prefix to suggest, e.g. `runtype flows list`.
+*/
+function printNextCursorHint(commandPath, pagination) {
+	const hasMore = pagination?.hasMore ?? pagination?.hasNextPage ?? false;
+	const nextCursor = pagination?.nextCursor !== void 0 ? pagination.nextCursor : pagination?.cursor ?? null;
+	if (!hasMore || !nextCursor) return;
+	console.log(chalk.yellow("\n  More results available — fetch the next page with:") + chalk.dim(`\n    ${commandPath} --cursor ${nextCursor}`));
+}
+export { printJson as a, printDetail as i, buildListParams as n, printList as o, getTotalCount as r, printNextCursorHint as s, apiErrorDetails as t };
+