@runtypelabs/cli 2.59.1 → 2.59.2

package/dist/chunk-KPYN2vUp.js

@@ -0,0 +1,776 @@
+#!/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 { y as neutralizeCsvFormula } from "./chunk-ucu5lrDZ.js";
+import { r as createCliClient } from "./chunk-BW2fg46T.js";
+import { n as ensureAuth } from "./chunk-CJraEBVd.js";
+import { a as printJson, r as getTotalCount, s as printNextCursorHint } from "./chunk-CcFCyqbB.js";
+import { t as readJsonFile } from "./chunk-DGv7X9S_.js";
+import { n as renderMessageContentWithImages, r as detectImageProtocol, t as renderMessageContent } from "./chunk-CW6AzBH6.js";
+import { Command } from "commander";
+import chalk from "chalk";
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname } from "path";
+// src/commands/records.ts
+/**
+* Resolve the owner-key intent of a `records update` invocation into the body field the API expects.
+* `--owner-id` reassigns the owner; `--clear-owner` sends an explicit `null`; omitting both leaves the stored owner untouched.
+* The two are mutually exclusive; an empty `--owner-id` is rejected here rather than sent as a 400.
+* Returns `undefined` when neither flag was passed.
+*/
+function resolveOwnerIdUpdate(options) {
+	if (options.clearOwner && options.ownerId !== void 0) throw new Error("--owner-id and --clear-owner are mutually exclusive");
+	if (options.clearOwner) return { ownerId: null };
+	if (options.ownerId === void 0) return void 0;
+	if (options.ownerId.trim() === "") throw new Error("--owner-id cannot be empty; use --clear-owner to remove the owner");
+	return { ownerId: options.ownerId };
+}
+/**
+* Print a record's detail + any messages to stdout (the non-Ink path). When
+* `imageProtocol` is set (interactive, image-capable terminal), image parts in
+* message content are rendered inline; otherwise every part collapses to a text
+* marker. Records with no `messages` print exactly as before (id/name/type/meta).
+*/
+function printRecordDetail(data, imageProtocol) {
+	console.log(`  ID: ${data.id}`);
+	console.log(`  Name: ${data.name}`);
+	console.log(`  Type: ${data.type}`);
+	if (data.ownerId) console.log(`  Owner: ${data.ownerId}`);
+	if (data.metadata) console.log(`  Metadata: ${JSON.stringify(data.metadata, null, 2)}`);
+	const messages = data.messages ?? [];
+	if (messages.length === 0) return;
+	console.log(chalk.cyan(`\nMessages (${messages.length}):`));
+	for (const msg of messages) {
+		const role = typeof msg.role === "string" ? msg.role : "message";
+		const rolePrefix = `  ${(role === "user" ? chalk.blue : role === "assistant" ? chalk.green : chalk.gray)(role)}: `;
+		if (imageProtocol) {
+			const { text, images } = renderMessageContentWithImages(msg.content, imageProtocol);
+			process.stdout.write(`${rolePrefix}${text}\n`);
+			for (const seq of images) process.stdout.write(`${seq}\n`);
+		} else console.log(`${rolePrefix}${renderMessageContent(msg.content)}`);
+	}
+}
+const recordsCommand = new Command("records").description("Manage records");
+recordsCommand.command("list").description("List all records").option("--type <type>", "Filter by record type").option("--owner-id <id>", "Filter by owner key (the indexed owner_id column)").option("--limit <n>", "Limit number of results", "20").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 = { limit: options.limit };
+	if (options.type) params.type = options.type;
+	if (options.ownerId) params.ownerId = options.ownerId;
+	if (options.cursor) params.cursor = options.cursor;
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.get("/records", params);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			const records = data.data ?? [];
+			if (records.length === 0) {
+				console.log("No records found");
+				return;
+			}
+			console.log("Your Records:");
+			for (const record of records) {
+				console.log(`  ${record.id} - ${record.name} (${record.type})`);
+				if (record.metadata && Object.keys(record.metadata).length > 0) console.log(`    ${JSON.stringify(record.metadata)}`);
+			}
+			const total = getTotalCount(data.pagination);
+			if (total !== void 0) console.log(`\n  Total: ${total} records`);
+			printNextCursorHint("runtype records list", data.pagination);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to fetch records: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [items, setItems] = useState(null);
+		const [error, setError] = useState(null);
+		const [total, setTotal] = useState();
+		useEffect(() => {
+			client.get("/records", params).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 Records",
+			items,
+			error,
+			loading: items === null && error === null,
+			total,
+			renderCard: (item) => {
+				const record = item;
+				return React.createElement(EntityCard, { fields: [
+					{
+						label: "ID",
+						value: record.id,
+						color: "green"
+					},
+					{
+						label: "Name",
+						value: record.name
+					},
+					{
+						label: "Type",
+						value: record.type
+					},
+					{
+						label: "Metadata",
+						value: record.metadata && Object.keys(record.metadata).length > 0 ? JSON.stringify(record.metadata) : null,
+						color: "gray"
+					}
+				] });
+			},
+			emptyMessage: "No records found"
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+recordsCommand.command("get <id>").description("Get record details").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(`/records/${id}`);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			printRecordDetail(data, imageProtocol);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to fetch record: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [items, setItems] = useState(null);
+		const [error, setError] = useState(null);
+		useEffect(() => {
+			client.get(`/records/${id}`).then((res) => setItems([res])).catch((err) => setError(err instanceof Error ? err : new Error(String(err))));
+		}, []);
+		return React.createElement(DataList, {
+			title: "Record",
+			items,
+			error,
+			loading: items === null && error === null,
+			renderCard: (item) => {
+				const record = item;
+				const messages = record.messages ?? [];
+				const fields = [
+					{
+						label: "ID",
+						value: record.id,
+						color: "green"
+					},
+					{
+						label: "Name",
+						value: record.name
+					},
+					{
+						label: "Type",
+						value: record.type
+					},
+					{
+						label: "Owner",
+						value: record.ownerId ?? null
+					},
+					{
+						label: "Metadata",
+						value: record.metadata ? JSON.stringify(record.metadata) : null
+					}
+				];
+				if (messages.length > 0) fields.push({
+					label: `Messages (${messages.length})`,
+					value: messages.map((m) => `${m.role ?? "message"}: ${renderMessageContent(m.content)}`).join("\n")
+				});
+				return React.createElement(EntityCard, { fields });
+			}
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+recordsCommand.command("results <id>").description("Get step-level execution results for a record").option("--flow-id <flowId>", "Filter by flow ID").option("--batch-id <batchId>", "Filter by batch ID").option("--status <status>", "Filter by status").option("--limit <n>", "Limit number of results").option("--offset <n>", "Offset for pagination").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);
+	const params = {
+		...options.flowId ? { flowId: options.flowId } : {},
+		...options.batchId ? { batchId: options.batchId } : {},
+		...options.status ? { status: options.status } : {},
+		...options.limit ? { limit: parseInt(options.limit, 10) } : {},
+		...options.offset ? { offset: parseInt(options.offset, 10) } : {}
+	};
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.records.getStepResults(id, params);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			const results = data.data ?? [];
+			if (results.length === 0) {
+				console.log(chalk.yellow("No step results found"));
+				return;
+			}
+			for (const r of results) console.log(`  ${chalk.green(r.id)}  ${r.stepName} (${r.stepType})  ${r.status}` + (r.modelUsed ? `  ${r.modelUsed}` : ""));
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to fetch step results: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [items, setItems] = useState(null);
+		const [error, setError] = useState(null);
+		useEffect(() => {
+			client.records.getStepResults(id, params).then((res) => setItems(res.data ?? [])).catch((err) => setError(err instanceof Error ? err : new Error(String(err))));
+		}, []);
+		return React.createElement(DataList, {
+			title: "Step results",
+			items,
+			error,
+			loading: items === null && error === null,
+			renderCard: (item) => {
+				const r = item;
+				return React.createElement(EntityCard, { fields: [
+					{
+						label: "ID",
+						value: r.id,
+						color: "green"
+					},
+					{
+						label: "Step",
+						value: `${r.stepName} (${r.stepType})`
+					},
+					{
+						label: "Status",
+						value: r.status
+					},
+					{
+						label: "Model",
+						value: r.modelUsed ?? null
+					},
+					{
+						label: "Duration",
+						value: r.durationMs !== null ? `${r.durationMs}ms` : null
+					}
+				] });
+			}
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+recordsCommand.command("costs <id>").description("Get aggregated cost breakdown for a record").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.records.getCosts(id);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			console.log(`  Total cost: $${data.totalCost}`);
+			console.log(`  Total tokens: ${data.totalTokens}`);
+			console.log(`  Executions: ${data.executionCount}`);
+			if (data.modelBreakdown.length > 0) {
+				console.log("  By model:");
+				for (const m of data.modelBreakdown) console.log(`    ${m.model}: $${m.cost}  ${m.tokens} tokens  ${m.count} calls`);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to fetch record costs: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [items, setItems] = useState(null);
+		const [error, setError] = useState(null);
+		useEffect(() => {
+			client.records.getCosts(id).then((res) => setItems([res])).catch((err) => setError(err instanceof Error ? err : new Error(String(err))));
+		}, []);
+		return React.createElement(DataList, {
+			title: "Record costs",
+			items,
+			error,
+			loading: items === null && error === null,
+			renderCard: (item) => {
+				const c = item;
+				return React.createElement(EntityCard, { fields: [
+					{
+						label: "Total cost",
+						value: `$${c.totalCost}`,
+						color: "green"
+					},
+					{
+						label: "Total tokens",
+						value: String(c.totalTokens)
+					},
+					{
+						label: "Executions",
+						value: String(c.executionCount)
+					},
+					{
+						label: "Models",
+						value: c.modelBreakdown.map((m) => `${m.model} ($${m.cost})`).join(", ") || null
+					}
+				] });
+			}
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+recordsCommand.command("create").description("Create a new record").requiredOption("-n, --name <name>", "Record name").requiredOption("-t, --type <type>", "Record type").option("-m, --metadata <json>", "Metadata as JSON string").option("--owner-id <id>", "Owner key for the record (the indexed owner_id column)").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 metadata = {};
+	if (options.metadata) try {
+		metadata = JSON.parse(options.metadata);
+	} catch {
+		console.error(chalk.red("Invalid JSON in metadata"));
+		process.exit(1);
+	}
+	const ownerFields = options.ownerId !== void 0 ? { ownerId: options.ownerId } : {};
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.post("/records", {
+				name: options.name,
+				type: options.type,
+				...ownerFields,
+				metadata
+			});
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			console.log(`  ID: ${data.id}`);
+			console.log(`  Name: ${data.name}`);
+			console.log(`  Type: ${data.type}`);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to create record: ${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("/records", {
+				name: options.name,
+				type: options.type,
+				...ownerFields,
+				metadata
+			}).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 record...",
+			success,
+			successMessage: "Record created",
+			error,
+			result: result ? React.createElement(EntityCard, { fields: [
+				{
+					label: "ID",
+					value: result.id,
+					color: "green"
+				},
+				{
+					label: "Name",
+					value: result.name
+				},
+				{
+					label: "Type",
+					value: result.type
+				}
+			] }) : void 0
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+recordsCommand.command("delete <id>").description("Delete a record").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.records.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 record: ${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.delete(`/records/${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 record ${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 record...",
+			success,
+			successMessage: "Record deleted",
+			error
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+recordsCommand.command("update <id>").description("Update a record (name, type, and/or metadata)").option("-n, --name <name>", "New record name").option("-t, --type <type>", "New record type").option("-m, --metadata <json>", "Metadata as JSON string").option("--owner-id <id>", "Reassign the owner key (the indexed owner_id column)").option("--clear-owner", "Clear the owner key (sends an explicit null)").option("--from-file <path>", "Read the full update payload from a JSON file").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);
+	if (options.name !== void 0) body.name = options.name;
+	if (options.type !== void 0) body.type = options.type;
+	if (options.metadata !== void 0) try {
+		body.metadata = JSON.parse(options.metadata);
+	} catch {
+		console.error(chalk.red("Invalid JSON in metadata"));
+		process.exit(1);
+	}
+	try {
+		const ownerUpdate = resolveOwnerIdUpdate(options);
+		if (ownerUpdate) body.ownerId = ownerUpdate.ownerId;
+	} catch (error) {
+		console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+		process.exit(1);
+	}
+	if (Object.keys(body).length === 0) {
+		console.error(chalk.red("Error: provide at least one of --name, --type, --metadata, --owner-id, --clear-owner, or --from-file"));
+		process.exit(1);
+	}
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.put(`/records/${id}`, body);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			console.log(chalk.green("Record updated"));
+			console.log(`  ID: ${chalk.green(data.id)}`);
+			console.log(`  Name: ${data.name}`);
+			console.log(`  Type: ${data.type}`);
+			console.log(`  Owner: ${data.ownerId ?? "(none)"}`);
+			if (data.metadata) console.log(`  Metadata: ${JSON.stringify(data.metadata)}`);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to update record: ${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.put(`/records/${id}`, body);
+					setResultNode(React.createElement(EntityCard, { fields: [
+						{
+							label: "ID",
+							value: data.id,
+							color: "green"
+						},
+						{
+							label: "Name",
+							value: data.name
+						},
+						{
+							label: "Type",
+							value: data.type
+						},
+						{
+							label: "Owner",
+							value: data.ownerId ?? null
+						},
+						{
+							label: "Metadata",
+							value: data.metadata ? JSON.stringify(data.metadata) : null,
+							color: "gray"
+						}
+					] }));
+					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: "Updating record...",
+			success,
+			successMessage: "Record updated",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+recordsCommand.command("bulk-delete").description("Bulk delete records (payload via --from-file)").requiredOption("--from-file <path>", "JSON file with the bulk-delete payload (e.g. { \"ids\": [...] })").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 body = readJsonFile(options.fromFile);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.post("/records/bulk-delete", body);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			console.log(chalk.green(`Deleted ${data.deleted} record(s)`));
+			if (data.deletedIds.length > 0) console.log(`  Deleted IDs: ${data.deletedIds.join(", ")}`);
+			if (data.notFoundIds && data.notFoundIds.length > 0) console.log(chalk.yellow(`  Not found: ${data.notFoundIds.join(", ")}`));
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to bulk delete records: ${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.post("/records/bulk-delete", body);
+					setResultNode(React.createElement(EntityCard, { fields: [
+						{
+							label: "Deleted",
+							value: String(data.deleted),
+							color: "green"
+						},
+						{
+							label: "Deleted IDs",
+							value: data.deletedIds.join(", ") || "(none)"
+						},
+						{
+							label: "Not Found",
+							value: data.notFoundIds && data.notFoundIds.length > 0 ? data.notFoundIds.join(", ") : null,
+							color: "yellow"
+						}
+					] }));
+					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: "Deleting records...",
+			success,
+			successMessage: "Records deleted",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+recordsCommand.command("bulk-edit").description("Bulk edit record metadata (payload via --from-file)").requiredOption("--from-file <path>", "JSON file with the bulk-edit payload (recordIds/recordFilter, updates, deleteFields, dryRun, applyToAll)").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 body = readJsonFile(options.fromFile);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.post("/records/bulk-edit", body);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			console.log(chalk.green(`Edited ${data.recordIds.length} record(s)`));
+			for (const diff of data.data) {
+				console.log(`  ${chalk.green(diff.id)}`);
+				console.log(`    before: ${JSON.stringify(diff.before)}`);
+				console.log(`    after:  ${JSON.stringify(diff.after)}`);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to bulk edit records: ${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.post("/records/bulk-edit", body);
+					setResultNode(React.createElement(EntityCard, { fields: [{
+						label: "Edited",
+						value: String(data.recordIds.length),
+						color: "green"
+					}, {
+						label: "Record IDs",
+						value: data.recordIds.join(", ") || "(none)"
+					}] }));
+					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: "Editing records...",
+			success,
+			successMessage: "Records edited",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+recordsCommand.command("export").description("Export records to a file").option("--type <type>", "Filter by record type").option("--owner-id <id>", "Filter by owner key (the indexed owner_id column)").option("--limit <n>", "Maximum records to export", "100").option("-o, --output <file>", "Output file path").option("--format <format>", "Export format (json, csv)", "json").action(async (options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	console.log(chalk.gray("Exporting records..."));
+	try {
+		const client = createCliClient(apiKey);
+		const params = { limit: options.limit };
+		if (options.type) params.type = options.type;
+		if (options.ownerId) params.ownerId = options.ownerId;
+		const records = (await client.get("/records", params)).data ?? [];
+		if (records.length === 0) {
+			console.log(chalk.yellow("No records to export"));
+			return;
+		}
+		let content;
+		if (options.format === "csv") {
+			const headers = [
+				"id",
+				"name",
+				"type",
+				"ownerId",
+				"metadata"
+			];
+			const rows = records.map((r) => [
+				r.id,
+				r.name,
+				r.type,
+				r.ownerId ?? "",
+				r.metadata ? JSON.stringify(r.metadata) : ""
+			]);
+			content = [headers.join(","), ...rows.map((r) => r.map(csvEscape).join(","))].join("\n");
+		} else content = JSON.stringify(records, null, 2);
+		const filename = options.output || `records-export-${Date.now()}.${options.format === "csv" ? "csv" : "json"}`;
+		writeFileSync(filename, content);
+		console.log(chalk.green(`Exported ${records.length} records to ${filename}`));
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		console.error(chalk.red(`Failed to export records: ${message}`));
+		process.exit(1);
+	}
+});
+recordsCommand.command("typegen").description("Generate TypeScript types for your schematized record collections. Writes a .d.ts that augments the @runtypelabs/sdk RecordCollections map so client.records.from(slug) types record metadata. Commit the file and re-run this in CI, diffing against the committed copy (e.g. `runtype records typegen -o runtype-records.d.ts && git diff --exit-code runtype-records.d.ts`), to catch collection-schema drift.").option("-o, --output <file>", "Write the declarations to a file (default: print to stdout)").action(async (options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	try {
+		const dts = await client.collections.typegen();
+		if (options.output) {
+			const dir = dirname(options.output);
+			if (dir && dir !== ".") mkdirSync(dir, { recursive: true });
+			writeFileSync(options.output, dts);
+			console.log(chalk.green(`Wrote record collection types to ${options.output}`));
+			return;
+		}
+		process.stdout.write(dts);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		console.error(chalk.red(`Failed to generate record types: ${message}`));
+		process.exit(1);
+	}
+});
+function csvEscape(value) {
+	const text = neutralizeCsvFormula(value);
+	if (text.includes(",") || text.includes("\"") || text.includes("\n")) return `"${text.replace(/"/g, "\"\"")}"`;
+	return text;
+}
+export { recordsCommand };
+