@runtypelabs/cli 2.59.1 → 2.59.2

package/dist/chunk-KcqPQJBi.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import { t as redactPiiText } from "./chunk-mG-4eZ6S.js";
+// src/lib/local-harness/delivery/redaction.ts
+const SENSITIVE_KEY = /^(?:authorization|password|secret|token|access[_-]?token|refresh[_-]?token|client[_-]?secret|credentials?|api[_-]?key|cookie|private[_-]?key|environment|env)$/i;
+const MARKER = "[redacted]";
+function redactHarnessValue(value, policy, secrets = []) {
+	let changed = false;
+	const text = (input) => {
+		let output = input;
+		for (const secret of secrets) if (secret.length >= 4) output = output.split(secret).join(MARKER);
+		output = output.replace(/\b(?:Bearer\s+\S+|(?:sk-|rt_|sst_)[A-Za-z0-9_-]{8,})/gi, MARKER);
+		output = output.replace(/(https?:\/\/)[^\s/@]+:[^\s/@]+@/gi, "$1[redacted]@");
+		output = output.replace(/([?&](?:key|token|secret|password|api_key|client[_-]?secret)=)[^&#\s]+/gi, "$1[redacted]");
+		if (policy === "redacted") output = redactPiiText(output, { mode: "redact" }).text;
+		if (output !== input) changed = true;
+		return output;
+	};
+	const walk = (input, depth) => {
+		if (depth > 24) {
+			changed = true;
+			return "[depth limit]";
+		}
+		if (typeof input === "string") {
+			if (/^\s*[[{]/.test(input)) try {
+				const parsed = JSON.parse(input);
+				return JSON.stringify(walk(parsed, depth + 1));
+			} catch {
+				return text(input);
+			}
+			return text(input);
+		}
+		if (input === null || typeof input === "boolean" || typeof input === "number") return input;
+		if (Array.isArray(input)) return input.map((entry) => walk(entry, depth + 1));
+		if (typeof input !== "object") return void 0;
+		return Object.fromEntries(Object.entries(input).map(([key, entry]) => {
+			if (SENSITIVE_KEY.test(key)) {
+				changed = true;
+				return [key, MARKER];
+			}
+			return [text(key), walk(entry, depth + 1)];
+		}));
+	};
+	return {
+		value: walk(value, 0),
+		changed
+	};
+}
+function redactObservation(observation, policy, secrets) {
+	if (policy === "metrics") {
+		const tool = observation.tool;
+		const removedContent = observation.native !== void 0 || observation.message !== void 0 || tool?.input !== void 0 || tool?.output !== void 0;
+		const result = redactHarnessValue({
+			kind: observation.kind,
+			nativeId: observation.nativeId,
+			nativeSessionId: observation.nativeSessionId,
+			nativeTurnId: observation.nativeTurnId,
+			parentId: observation.parentId,
+			nativeTime: observation.nativeTime,
+			...tool ? { tool: {
+				id: tool.id,
+				name: tool.name,
+				nativeName: tool.nativeName,
+				mcpServer: tool.mcpServer,
+				mcpTool: tool.mcpTool,
+				status: tool.status,
+				startedAt: tool.startedAt,
+				endedAt: tool.endedAt,
+				durationMs: tool.durationMs
+			} } : {},
+			...observation.usage ? { usage: observation.usage } : {},
+			...observation.permission ? { permission: observation.permission } : {},
+			...observation.lifecycle ? { lifecycle: { state: observation.lifecycle.state } } : {}
+		}, policy, secrets);
+		return {
+			observation: result.value,
+			changed: removedContent || result.changed
+		};
+	}
+	const result = redactHarnessValue(observation, policy, secrets);
+	return {
+		observation: result.value,
+		changed: result.changed
+	};
+}
+export { redactObservation as n, redactHarnessValue as t };
+

package/dist/chunk-N9H0JnoG.js

@@ -0,0 +1,349 @@
+#!/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, o as printList, r as getTotalCount, s as printNextCursorHint } from "./chunk-CcFCyqbB.js";
+import { t as readJsonFile } from "./chunk-DGv7X9S_.js";
+import { n as addExecutionInputOptions, r as resolveExecutionInput, t as runExecution } from "./chunk-Cs4pwCQ-.js";
+import { c as buildEntityPullCommand, n as FLOW_ENSURE_SPEC, s as buildEntityEnsureCommand } from "./chunk-BirUxTtH.js";
+import { Command } from "commander";
+import chalk from "chalk";
+// src/commands/flows.ts
+/** Build the typed list params the SDK endpoint expects from the CLI's string flags. */
+function flowsListParams(options) {
+	return {
+		limit: options.limit ? Number(options.limit) : void 0,
+		cursor: options.cursor
+	};
+}
+const flowsCommand = new Command("flows").description("Manage flows");
+flowsCommand.addCommand(buildEntityEnsureCommand(FLOW_ENSURE_SPEC));
+flowsCommand.addCommand(buildEntityPullCommand(FLOW_ENSURE_SPEC));
+flowsCommand.command("list").description("List all flows").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 listParams = flowsListParams(options);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.flows.list(listParams);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			printList(data.data, {
+				title: "Your Flows",
+				columns: [{
+					key: "id",
+					color: "green"
+				}, { key: "name" }],
+				emptyMessage: "No flows found",
+				total: getTotalCount(data.pagination)
+			});
+			printNextCursorHint("runtype flows list", data.pagination);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to fetch flows: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [items, setItems] = useState(null);
+		const [error, setError] = useState(null);
+		const [total, setTotal] = useState();
+		useEffect(() => {
+			client.flows.list(listParams).then((res) => {
+				setItems(res.data);
+				setTotal(getTotalCount(res.pagination));
+			}).catch((err) => setError(err instanceof Error ? err : new Error(String(err))));
+		}, []);
+		return React.createElement(DataList, {
+			title: "Your Flows",
+			items,
+			error,
+			loading: items === null && error === null,
+			total,
+			renderCard: (item) => {
+				const flow = item;
+				return React.createElement(EntityCard, { fields: [{
+					label: "ID",
+					value: flow.id,
+					color: "green"
+				}, {
+					label: "Name",
+					value: flow.name
+				}] });
+			},
+			emptyMessage: "No flows found"
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+flowsCommand.command("get <id>").description("Get flow details").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (id, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.flows.get(id);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			printDetail("Flow", [
+				{
+					label: "ID",
+					value: data.id
+				},
+				{
+					label: "Name",
+					value: data.name
+				},
+				{
+					label: "Steps",
+					value: data.stepCount ?? data.flowSteps?.length
+				}
+			]);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to fetch flow: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [items, setItems] = useState(null);
+		const [error, setError] = useState(null);
+		useEffect(() => {
+			client.flows.get(id).then((res) => setItems([res])).catch((err) => setError(err instanceof Error ? err : new Error(String(err))));
+		}, []);
+		return React.createElement(DataList, {
+			title: "Flow",
+			items,
+			error,
+			loading: items === null && error === null,
+			renderCard: (item) => {
+				const flow = item;
+				return React.createElement(EntityCard, { fields: [
+					{
+						label: "ID",
+						value: flow.id,
+						color: "green"
+					},
+					{
+						label: "Name",
+						value: flow.name
+					},
+					{
+						label: "Steps",
+						value: flow.stepCount ?? flow.flowSteps?.length
+					}
+				] });
+			}
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+addExecutionInputOptions(flowsCommand.command("run <id>").description("Execute a flow via dispatch").option("-r, --record <id>", "Record ID to run with").option("-m, --message <text>", "Message to send").option("--stream", "Stream the response (default)", true).option("--no-stream", "Wait for complete response").option("--json", "Output one final JSON result").option("--jsonl", "Output stream events and a terminal execution_summary as JSON lines")).action(async (flowId, options) => {
+	await runExecution(options, () => ({
+		...resolveExecutionInput(options),
+		flow: { id: flowId },
+		options: { streamResponse: options.stream }
+	}), (client, payload) => options.stream ? client.dispatch.executeStream(payload) : client.dispatch.execute(payload), "flow");
+});
+flowsCommand.command("create").description("Create a new flow").requiredOption("-n, --name <name>", "Flow name").option("-d, --description <desc>", "Flow description").option("--from-file <file>", "Import flow from JSON file").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);
+	let body = {
+		name: options.name,
+		description: options.description
+	};
+	if (options.fromFile) {
+		body = { ...readJsonFile(options.fromFile, {
+			label: "flow file",
+			unwrapKey: "flow"
+		}) };
+		if (options.name !== void 0) body.name = options.name;
+		if (options.description !== void 0) body.description = options.description;
+	}
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.post("/flows", body);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			console.log(`  ID: ${chalk.green(data.id)}`);
+			console.log(`  Name: ${data.name}`);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to create flow: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [success, setSuccess] = useState(null);
+		const [error, setError] = useState(null);
+		const [result, setResult] = useState(null);
+		useEffect(() => {
+			client.post("/flows", body).then((data) => {
+				setResult(data);
+				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: "Creating flow...",
+			success,
+			successMessage: "Flow created",
+			error,
+			result: result ? React.createElement(EntityCard, { fields: [{
+				label: "ID",
+				value: result.id,
+				color: "green"
+			}, {
+				label: "Name",
+				value: result.name
+			}] }) : void 0
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+flowsCommand.command("update <id>").description("Update a flow").option("-n, --name <name>", "New flow name").option("-d, --description <desc>", "New flow description").option("--from-file <file>", "Update flow from JSON file (full body)").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (id, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	let body = {};
+	if (options.fromFile) body = readJsonFile(options.fromFile, {
+		label: "flow file",
+		unwrapKey: "flow"
+	});
+	if (options.name !== void 0) body.name = options.name;
+	if (options.description !== void 0) body.description = options.description;
+	if (Object.keys(body).length === 0) {
+		console.error(chalk.red("Error: provide at least one of --name, --description, or --from-file"));
+		process.exit(1);
+	}
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.put(`/flows/${id}`, body);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			console.log(chalk.green("Flow updated"));
+			console.log(`  ID: ${chalk.green(data.id)}`);
+			console.log(`  Name: ${data.name}`);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to update flow: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [success, setSuccess] = useState(null);
+		const [error, setError] = useState(null);
+		const [result, setResult] = useState(null);
+		useEffect(() => {
+			client.put(`/flows/${id}`, body).then((data) => {
+				setResult(data);
+				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: "Updating flow...",
+			success,
+			successMessage: "Flow updated",
+			error,
+			result: result ? React.createElement(EntityCard, { fields: [{
+				label: "ID",
+				value: result.id,
+				color: "green"
+			}, {
+				label: "Name",
+				value: result.name
+			}] }) : void 0
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+flowsCommand.command("delete <id>").description("Delete a flow").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (id, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	if (!isTTY(options)) {
+		try {
+			await client.flows.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 flow: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [confirmed, setConfirmed] = useState(null);
+		const [loading, setLoading] = useState(false);
+		const [success, setSuccess] = useState(null);
+		const [error, setError] = useState(null);
+		useEffect(() => {
+			if (confirmed !== true) return void 0;
+			setLoading(true);
+			client.flows.delete(id).then(() => {
+				setSuccess(true);
+				setLoading(false);
+			}).catch((err) => {
+				setError(err instanceof Error ? err : new Error(String(err)));
+				setSuccess(false);
+				setLoading(false);
+			});
+		}, [confirmed]);
+		if (confirmed === null) return React.createElement(ConfirmPrompt, {
+			message: `Delete flow ${id}?`,
+			onConfirm: (val) => setConfirmed(val)
+		});
+		if (confirmed === false) return React.createElement(MutationResult, {
+			loading: false,
+			success: true,
+			successMessage: "Cancelled",
+			error: null
+		});
+		return React.createElement(MutationResult, {
+			loading,
+			loadingLabel: "Deleting flow...",
+			success,
+			successMessage: "Flow deleted",
+			error
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+export { flowsCommand };
+