@runtypelabs/cli 2.59.0 → 2.59.2

package/dist/chunk-0x7UKC1U.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// src/lib/local-harness/types.ts
+const HARNESS_LIMITS = {
+	maxSessions: 8,
+	maxQueuedTurnsPerSession: 1,
+	maxEventBytes: 131072,
+	maxBatchBytes: 524288,
+	maxTurnBytes: 2097152,
+	maxSpoolBytes: 16777216,
+	maxControlReplyBytes: 131072,
+	deliveryTimeoutMs: 1e4,
+	spoolRetentionMs: 864e5,
+	cancelGraceMs: 1e3,
+	maxTurnTimeoutMs: 3e5
+};
+export { HARNESS_LIMITS as t };
+

package/dist/chunk-2ySxXtcg.js

@@ -0,0 +1,418 @@
+#!/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, s as printNextCursorHint } from "./chunk-CcFCyqbB.js";
+import { t as readJsonFile } from "./chunk-DGv7X9S_.js";
+import { Command } from "commander";
+import chalk from "chalk";
+// src/commands/collections.ts
+/**
+* Record collections: a collection registers a record type (slug =
+* records.type) and optionally owns a metadata schema, validated at every
+* record write seam according to its validation mode (off | warn | enforce).
+*/
+function parseSchemaOption(options) {
+	if (options.schemaFile) return readJsonFile(options.schemaFile);
+	if (options.schema !== void 0) try {
+		return JSON.parse(options.schema);
+	} catch {
+		console.error(chalk.red("Invalid JSON in --schema"));
+		process.exit(1);
+	}
+}
+function collectionFields(collection) {
+	return [
+		{
+			label: "Slug",
+			value: collection.slug,
+			color: "green"
+		},
+		{
+			label: "Name",
+			value: collection.displayName
+		},
+		{
+			label: "Mode",
+			value: collection.validationMode
+		},
+		{
+			label: "Schema",
+			value: collection.schema ? `v${collection.schemaVersion}` : "none"
+		},
+		{
+			label: "Records",
+			value: collection.recordCount !== void 0 ? String(collection.recordCount) : null
+		},
+		{
+			label: "Description",
+			value: collection.description ?? null,
+			color: "gray"
+		}
+	];
+}
+function printCollectionDetail(collection) {
+	console.log(`  Slug: ${chalk.green(collection.slug)}`);
+	console.log(`  Name: ${collection.displayName}`);
+	console.log(`  Mode: ${collection.validationMode}`);
+	if (collection.description) console.log(`  Description: ${collection.description}`);
+	if (collection.recordCount !== void 0) console.log(`  Records: ${collection.recordCount}`);
+	if (collection.schema) {
+		console.log(`  Schema (v${collection.schemaVersion}):`);
+		console.log(JSON.stringify(collection.schema, null, 2).split("\n").map((line) => `    ${line}`).join("\n"));
+	} else console.log("  Schema: none");
+}
+const collectionsCommand = new Command("collections").description("Manage record collections (registered record types with optional metadata schemas)");
+collectionsCommand.command("list").description("List collections").option("--limit <n>", "Limit number of results", "25").option("--cursor <cursor>", "Pagination cursor for the next page").option("--count", "Include per-collection record counts").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: parseInt(options.limit, 10),
+		...options.cursor ? { cursor: options.cursor } : {},
+		...options.count ? { includeCount: true } : {}
+	};
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.collections.list(params);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			const collections = data.data ?? [];
+			if (collections.length === 0) {
+				console.log("No collections found");
+				return;
+			}
+			console.log("Your Collections:");
+			for (const collection of collections) {
+				const schemaTag = collection.schema ? chalk.gray(` schema v${collection.schemaVersion}`) : chalk.gray(" schemaless");
+				const countTag = collection.recordCount !== void 0 ? ` (${collection.recordCount} records)` : "";
+				console.log(`  ${chalk.green(collection.slug)} - ${collection.displayName} [${collection.validationMode}]${schemaTag}${countTag}`);
+			}
+			printNextCursorHint("runtype collections list", data.pagination);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to fetch collections: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [items, setItems] = useState(null);
+		const [error, setError] = useState(null);
+		useEffect(() => {
+			client.collections.list(params).then((res) => setItems(res.data ?? [])).catch((err) => setError(err instanceof Error ? err : new Error(String(err))));
+		}, []);
+		return React.createElement(DataList, {
+			title: "Your Collections",
+			items,
+			error,
+			loading: items === null && error === null,
+			renderCard: (item) => React.createElement(EntityCard, { fields: collectionFields(item) }),
+			emptyMessage: "No collections found"
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+collectionsCommand.command("get <slug>").description("Get collection details").option("--history", "Include the schema version history").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (slug, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	const params = options.history ? { includeHistory: true } : void 0;
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.collections.get(slug, params);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			printCollectionDetail(data);
+			const history = data.history;
+			if (history && history.length > 0) {
+				console.log(chalk.cyan(`\nSchema history (${history.length}):`));
+				for (const entry of history) console.log(`  v${entry.version} ${entry.changeKind} ${chalk.gray(String(entry.createdAt))}`);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to fetch collection: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [items, setItems] = useState(null);
+		const [error, setError] = useState(null);
+		useEffect(() => {
+			client.collections.get(slug, params).then((res) => setItems([res])).catch((err) => setError(err instanceof Error ? err : new Error(String(err))));
+		}, []);
+		return React.createElement(DataList, {
+			title: "Collection",
+			items,
+			error,
+			loading: items === null && error === null,
+			renderCard: (item) => React.createElement(EntityCard, { fields: collectionFields(item) })
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+collectionsCommand.command("create").description("Register a record type as a collection").requiredOption("-s, --slug <slug>", "Record type to register (matches records.type)").requiredOption("-n, --name <name>", "Display name").option("-d, --description <text>", "Description").option("--schema <json>", "Metadata schema as a JSON string (constrained dialect)").option("--schema-file <path>", "Read the metadata schema from a JSON file").option("--mode <mode>", "Validation mode: off | warn | enforce (default off)").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 schema = parseSchemaOption(options);
+	const body = {
+		slug: options.slug,
+		displayName: options.name,
+		...options.description !== void 0 ? { description: options.description } : {},
+		...schema !== void 0 ? { schema } : {},
+		...options.mode !== void 0 ? { validationMode: options.mode } : {}
+	};
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.collections.create(body);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			console.log(chalk.green("Collection created"));
+			printCollectionDetail(data);
+			if (!data.schema) console.log(chalk.gray(`\nPropose a schema from existing data: runtype collections infer ${data.slug}`));
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to create collection: ${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.collections.create(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 collection...",
+			success,
+			successMessage: "Collection created",
+			error,
+			result: result ? React.createElement(EntityCard, { fields: collectionFields(result) }) : void 0
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+collectionsCommand.command("update <slug>").description("Update a collection (display fields, schema, and/or validation mode)").option("-n, --name <name>", "New display name").option("-d, --description <text>", "New description").option("--schema <json>", "New metadata schema as a JSON string").option("--schema-file <path>", "Read the new metadata schema from a JSON file").option("--mode <mode>", "New validation mode: off | warn | enforce").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 (slug, 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.displayName = options.name;
+	if (options.description !== void 0) body.description = options.description;
+	const schema = parseSchemaOption(options);
+	if (schema !== void 0) body.schema = schema;
+	if (options.mode !== void 0) body.validationMode = options.mode;
+	if (Object.keys(body).length === 0) {
+		console.error(chalk.red("Error: provide at least one of --name, --description, --schema, --schema-file, --mode, or --from-file"));
+		process.exit(1);
+	}
+	const printUpdateResult = (data) => {
+		console.log(chalk.green("Collection updated"));
+		printCollectionDetail(data.collection);
+		if (data.schemaChange) {
+			console.log(`  Schema change: ${data.schemaChange.kind}`);
+			for (const change of data.schemaChange.breakingChanges ?? []) console.log(chalk.yellow(`    ${change}`));
+		}
+		if (data.enforceCheck) {
+			const { checked, failed, truncated } = data.enforceCheck;
+			const line = `  Enforce check: ${failed} of ${checked} existing records would fail${truncated ? " (truncated)" : ""}`;
+			console.log(failed > 0 ? chalk.yellow(line) : chalk.green(line));
+		}
+	};
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.collections.update(slug, body);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			printUpdateResult(data);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to update collection: ${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(() => {
+			client.collections.update(slug, body).then((data) => {
+				const fields = collectionFields(data.collection);
+				if (data.schemaChange) fields.push({
+					label: "Schema change",
+					value: data.schemaChange.kind
+				});
+				if (data.enforceCheck) fields.push({
+					label: "Enforce check",
+					value: `${data.enforceCheck.failed} of ${data.enforceCheck.checked} existing records would fail`,
+					color: data.enforceCheck.failed > 0 ? "yellow" : "green"
+				});
+				setResultNode(React.createElement(EntityCard, { fields }));
+				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 collection...",
+			success,
+			successMessage: "Collection updated",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+collectionsCommand.command("delete <slug>").description("Delete a collection registration (records of the type are not touched)").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (slug, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	if (!isTTY(options)) {
+		try {
+			await client.collections.delete(slug);
+			console.log(JSON.stringify({
+				status: "deleted",
+				slug
+			}, null, 2));
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to delete collection: ${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.collections.delete(slug).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 collection ${slug}? Records of this type are not touched.`,
+			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 collection...",
+			success,
+			successMessage: "Collection deleted",
+			error
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+collectionsCommand.command("infer <slug>").description("Propose a metadata schema from existing records (saves nothing)").option("--sample <n>", "How many of the most recently updated records to sample (1-1000)").option("-o, --output <file>", "Write the proposed schema JSON to a file").option("--json", "Output the full proposal as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (slug, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	const params = options.sample ? { sample: parseInt(options.sample, 10) } : void 0;
+	try {
+		const proposal = await client.collections.inferSchema(slug, params);
+		if (options.output) {
+			const { writeFileSync } = await import("fs");
+			writeFileSync(options.output, JSON.stringify(proposal.schema, null, 2));
+			console.log(chalk.green(`Proposed schema written to ${options.output}`));
+		}
+		if (options.json) {
+			printJson(proposal);
+			return;
+		}
+		console.log(`Sampled ${proposal.sampledRecords} of ${proposal.totalRecords} "${slug}" records`);
+		if (!proposal.schema) {
+			console.log(chalk.yellow("No schema could be inferred (no records or no stable fields)"));
+			return;
+		}
+		console.log(chalk.cyan("\nProposed fields:"));
+		for (const field of proposal.fields) {
+			const enumTag = field.enum ? ` enum(${field.enum.join("|")})` : "";
+			const format = field.format ? `:${field.format}` : "";
+			console.log(`  ${field.name}: ${field.type}${format}${enumTag}  ${chalk.gray(`confidence ${Math.round(field.confidence * 100)}%, present in ${Math.round(field.presence * 100)}%`)}`);
+		}
+		if (proposal.skippedKeys.length > 0) console.log(chalk.gray(`\nSkipped keys: ${proposal.skippedKeys.join(", ")}`));
+		console.log(chalk.cyan("\nProposed schema:"));
+		console.log(JSON.stringify(proposal.schema, null, 2));
+		console.log(chalk.gray(`\nNothing was saved. Persist it with: runtype collections update ${slug} --schema-file <file> --mode warn`));
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		console.error(chalk.red(`Failed to infer schema: ${message}`));
+		process.exit(1);
+	}
+});
+collectionsCommand.command("validate <slug>").description("Dry-run existing records against a schema (writes nothing)").option("--schema <json>", "Proposed schema as a JSON string (defaults to the saved schema)").option("--schema-file <path>", "Read the proposed schema from a JSON file").option("--json", "Output the full result as JSON").action(async (slug, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	const schema = parseSchemaOption(options);
+	try {
+		const result = await client.collections.validateExisting(slug, schema !== void 0 ? { schema } : void 0);
+		if (options.json) {
+			printJson(result);
+			return;
+		}
+		const summary = `${result.failed} of ${result.checked} existing "${slug}" records would fail${result.truncated ? " (truncated at the check cap)" : ""}`;
+		console.log(result.failed > 0 ? chalk.yellow(summary) : chalk.green(summary));
+		for (const example of result.examples) {
+			console.log(`  ${chalk.green(example.recordId)} ${example.name}`);
+			for (const err of example.errors) console.log(chalk.yellow(`    ${err.field || "(document)"}: [${err.code}] ${err.message}`));
+		}
+		if (result.failed === 0) console.log(chalk.gray(`\nSafe to enforce: runtype collections update ${slug} --mode enforce`));
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		console.error(chalk.red(`Failed to validate records: ${message}`));
+		process.exit(1);
+	}
+});
+export { collectionsCommand };
+