@runtypelabs/cli 2.59.0 → 2.59.2

package/dist/chunk-h6oavj0t.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import { a as getCliConfig, c as loadEffectiveContext, l as normalizeApiUrl, u as redactEffectiveContext } from "./index.js";
+import { Command } from "commander";
+import chalk from "chalk";
+// src/commands/config.ts
+const CLI_CONFIG_KEYS = [
+	"apiUrl",
+	"defaultModel",
+	"defaultTemperature",
+	"outputFormat",
+	"streamResponses"
+];
+const isCliConfigKey = (value) => {
+	return CLI_CONFIG_KEYS.includes(value);
+};
+const configCommand = new Command("config").description("Manage CLI configuration");
+configCommand.command("context").description("Show the effective API target and credential source without exposing keys (offline)").option("--json", "Output as JSON").action(async (options) => {
+	const context = redactEffectiveContext(await loadEffectiveContext());
+	if (options.json) {
+		console.log(JSON.stringify(context, null, 2));
+		return;
+	}
+	console.log(`API URL: ${context.apiUrl} (${context.apiUrlSource})`);
+	console.log(`Credential source: ${context.credentialSource}`);
+	console.log(`Organization: ${context.orgId ?? "unknown"} (not verified; use auth whoami)`);
+	console.log(`Login selected by: ${context.accountSource}${context.requestedOrgId ? ` (${context.requestedOrgId})` : ""}`);
+	if (context.projectLink) console.log(`Project link: ${context.projectLink}`);
+	if (context.credentialStore) console.log(`Credential stored in: ${context.credentialStore}`);
+});
+configCommand.command("get [key]").description("Get configuration value").action((key) => {
+	const config = getCliConfig();
+	if (key) {
+		if (!isCliConfigKey(key)) {
+			console.log(chalk.yellow(`Configuration key '${key}' not found`));
+			return;
+		}
+		const value = config.get(key);
+		if (value !== void 0) console.log(value);
+		else console.log(chalk.yellow(`Configuration key '${key}' not found`));
+	} else {
+		const allConfig = config.store;
+		if (Object.keys(allConfig).length > 0) {
+			console.log(chalk.cyan("Current Configuration:"));
+			for (const [k, v] of Object.entries(allConfig)) console.log(`  ${chalk.green(k)}: ${v}`);
+		} else console.log(chalk.gray("No configuration set"));
+	}
+});
+configCommand.command("set <key> <value>").description("Set configuration value").action((key, value) => {
+	const config = getCliConfig();
+	if (!isCliConfigKey(key)) {
+		console.log(chalk.red(`Invalid configuration key: ${key}`));
+		console.log(chalk.gray(`Valid keys: ${CLI_CONFIG_KEYS.join(", ")}`));
+		process.exit(1);
+	}
+	let parsedValue;
+	switch (key) {
+		case "apiUrl":
+			parsedValue = normalizeApiUrl(value);
+			break;
+		case "defaultTemperature":
+			{
+				const temperature = parseFloat(value);
+				if (isNaN(temperature) || temperature < 0 || temperature > 1) {
+					console.log(chalk.red("Temperature must be a number between 0 and 1"));
+					process.exit(1);
+				}
+				parsedValue = temperature;
+			}
+			break;
+		case "streamResponses":
+			parsedValue = value === "true";
+			break;
+		case "outputFormat":
+			if (![
+				"table",
+				"json",
+				"plain"
+			].includes(value)) {
+				console.log(chalk.red("Output format must be: table, json, or plain"));
+				process.exit(1);
+			}
+			parsedValue = value;
+			break;
+		default: parsedValue = value;
+	}
+	config.set(key, parsedValue);
+	console.log(chalk.green(`Configuration updated: ${key} = ${parsedValue}`));
+});
+configCommand.command("reset").description("Reset all configuration to defaults").action(() => {
+	getCliConfig().clear();
+	console.log(chalk.green("Configuration reset to defaults"));
+});
+configCommand.command("path").description("Show configuration file path").action(() => {
+	console.log(getCliConfig().path);
+});
+export { configCommand };
+

package/dist/chunk-i7DwkvvD.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { r as createCliClient } from "./chunk-BW2fg46T.js";
+import { RuntypeApiError } from "@runtypelabs/sdk";
+// src/lib/quick-start-api.ts
+function isObjectRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isQuickStartValidationResponse(value) {
+	if (!isObjectRecord(value) || typeof value.valid !== "boolean") return false;
+	if (value.valid === false) return typeof value.error === "string" && typeof value.code === "string";
+	return typeof value.templateId === "string" && isObjectRecord(value.agentCard);
+}
+function isQuickStartCreateResponse(value) {
+	if (!isObjectRecord(value) || typeof value.success !== "boolean") return false;
+	if (value.success === false) return typeof value.error === "string" && typeof value.code === "string";
+	return isObjectRecord(value.product) && Array.isArray(value.capabilities) && typeof value.redirectUrl === "string";
+}
+function getApiErrorData(error) {
+	return error instanceof RuntypeApiError ? error.data : void 0;
+}
+async function validateQuickStartUrl(url, apiUrl) {
+	const client = createCliClient(void 0, apiUrl);
+	try {
+		return await client.post("/quick-start/validate", { url });
+	} catch (error) {
+		const data = getApiErrorData(error);
+		if (isQuickStartValidationResponse(data)) return data;
+		throw error;
+	}
+}
+async function createQuickStartProduct(apiKey, input, apiUrl) {
+	const client = createCliClient(apiKey, apiUrl);
+	try {
+		return await client.post("/quick-start/create", input);
+	} catch (error) {
+		const data = getApiErrorData(error);
+		if (isQuickStartCreateResponse(data)) return data;
+		throw error;
+	}
+}
+export { validateQuickStartUrl as n, createQuickStartProduct as t };
+

package/dist/chunk-mG-4eZ6S.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+// ../shared/dist/chunk-DqvHhX2A.mjs
+/**
+* Default entity set for redaction.
+*
+* IP_ADDRESS is intentionally EXCLUDED: infrastructure logs legitimately contain
+* server IPs, so the false-positive cost of redacting every dotted-quad by
+* default is too high. Callers that want it opt in via `policy.entities`.
+*/
+const DEFAULT_PII_ENTITIES = [
+	"EMAIL_ADDRESS",
+	"PHONE_NUMBER",
+	"CREDIT_CARD",
+	"US_SSN",
+	"CA_SIN",
+	"IBAN"
+];
+/** Luhn (mod-10) check over a run of ASCII digits. */
+function passesLuhn(digits) {
+	let sum = 0;
+	let double = false;
+	for (let i = digits.length - 1; i >= 0; i--) {
+		let d = digits.charCodeAt(i) - 48;
+		if (d < 0 || d > 9) return false;
+		if (double) {
+			d *= 2;
+			if (d > 9) d -= 9;
+		}
+		sum += d;
+		double = !double;
+	}
+	return sum % 10 === 0;
+}
+/**
+* ISO 7064 mod-97-10 check for IBANs. Rearranges (first four chars to the end),
+* expands letters to two-digit numbers (A=10 .. Z=35), then computes the value
+* mod 97 in bounded chunks so we never need BigInt or overflow a 53-bit float.
+*/
+function passesIbanMod97(iban) {
+	const rearranged = iban.slice(4) + iban.slice(0, 4);
+	let remainder = 0;
+	for (let i = 0; i < rearranged.length; i++) {
+		const code = rearranged.charCodeAt(i);
+		let piece;
+		if (code >= 48 && code <= 57) piece = String(code - 48);
+		else if (code >= 65 && code <= 90) piece = String(code - 55);
+		else if (code >= 97 && code <= 122) piece = String(code - 87);
+		else return false;
+		for (let j = 0; j < piece.length; j++) remainder = (remainder * 10 + (piece.charCodeAt(j) - 48)) % 97;
+	}
+	return remainder === 1;
+}
+/** Strip ASCII spaces and hyphens/dots used as visual separators. */
+function digitsOnly(value) {
+	let out = "";
+	for (let i = 0; i < value.length; i++) {
+		const c = value.charCodeAt(i);
+		if (c >= 48 && c <= 57) out += value[i];
+	}
+	return out;
+}
+const DETECTORS = [
+	{
+		entityType: "EMAIL_ADDRESS",
+		pattern: () => /[A-Za-z0-9._%+-]{1,64}@[A-Za-z0-9.-]{1,255}\.[A-Za-z]{2,24}/g,
+		validate: () => .95
+	},
+	{
+		entityType: "CREDIT_CARD",
+		pattern: () => /(?<![A-Za-z0-9])\d(?:[ -]?\d){12,18}(?![A-Za-z0-9])/g,
+		validate: (m) => {
+			const digits = digitsOnly(m[0]);
+			if (digits.length < 13 || digits.length > 19) return null;
+			return passesLuhn(digits) ? .97 : null;
+		}
+	},
+	{
+		entityType: "US_SSN",
+		pattern: () => /(?<![A-Za-z0-9-])(\d{3})-(\d{2})-(\d{4})(?![A-Za-z0-9-])/g,
+		validate: (m) => {
+			const area = m[1];
+			const group = m[2];
+			const serial = m[3];
+			if (area === "000" || area === "666" || area >= "900") return null;
+			if (group === "00") return null;
+			if (serial === "0000") return null;
+			return .9;
+		}
+	},
+	{
+		entityType: "CA_SIN",
+		pattern: () => /(?<![A-Za-z0-9-])(\d{3})([ -])(\d{3})\2(\d{3})(?![A-Za-z0-9-])/g,
+		validate: (m) => {
+			const digits = m[1] + m[3] + m[4];
+			const first = digits.charCodeAt(0) - 48;
+			if (first === 0 || first === 8) return null;
+			return passesLuhn(digits) ? .9 : null;
+		}
+	},
+	{
+		entityType: "PHONE_NUMBER",
+		pattern: () => /(?<![A-Za-z0-9])\+\d(?:[ .-]?\d){7,14}(?![A-Za-z0-9])/g,
+		validate: (m) => {
+			const digits = digitsOnly(m[0]);
+			return digits.length >= 8 && digits.length <= 15 ? .85 : null;
+		}
+	},
+	{
+		entityType: "PHONE_NUMBER",
+		pattern: () => /(?<![A-Za-z0-9])(?:\+?1[ .-]?)?(?:\(\d{3}\)[ .-]?|\d{3}[ .-])\d{3}[ .-]?\d{4}(?![A-Za-z0-9])/g,
+		validate: () => .85
+	},
+	{
+		entityType: "IBAN",
+		pattern: () => /(?<![A-Za-z0-9])[A-Za-z]{2}\d{2}[A-Za-z0-9]{11,30}(?![A-Za-z0-9])/g,
+		validate: (m) => passesIbanMod97(m[0]) ? .97 : null
+	},
+	{
+		entityType: "IP_ADDRESS",
+		pattern: () => /(?<![A-Za-z0-9.])(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})(?![A-Za-z0-9.])/g,
+		validate: (m) => {
+			for (let i = 1; i <= 4; i++) {
+				if (Number(m[i]) > 255) return null;
+				if (m[i].length > 1 && m[i].charCodeAt(0) === 48) return null;
+			}
+			return .8;
+		}
+	}
+];
+function analyzeWithDetectors(text, entities) {
+	const raw = [];
+	for (const detector of DETECTORS) {
+		if (!entities.has(detector.entityType)) continue;
+		const pattern = detector.pattern();
+		let match;
+		while ((match = pattern.exec(text)) !== null) {
+			if (match[0].length === 0) {
+				pattern.lastIndex++;
+				continue;
+			}
+			const confidence = detector.validate(match);
+			if (confidence === null) continue;
+			raw.push({
+				entityType: detector.entityType,
+				start: match.index,
+				end: match.index + match[0].length,
+				confidence
+			});
+		}
+	}
+	return resolveOverlaps(raw);
+}
+/**
+* Drop overlapping findings, preferring higher confidence then the longer span.
+* Sorts and dedupes by priority. Returns findings
+* sorted by `start` ascending.
+*/
+function resolveOverlaps(findings) {
+	if (findings.length <= 1) return findings;
+	const byPriority = [...findings].sort((a, b) => b.confidence - a.confidence || b.end - b.start - (a.end - a.start) || a.start - b.start);
+	const accepted = [];
+	for (const candidate of byPriority) if (!accepted.some((kept) => candidate.start < kept.end && kept.start < candidate.end)) accepted.push(candidate);
+	return accepted.sort((a, b) => a.start - b.start || a.end - b.end);
+}
+/** The built-in regex-tier analyzer. Stateless and safe to share. */
+const defaultRegexPiiAnalyzer = { analyze(text, entities) {
+	if (typeof text !== "string" || text.length === 0) return [];
+	return analyzeWithDetectors(text, entities);
+} };
+function resolvePolicyEntities(policy) {
+	const list = policy.entities && policy.entities.length > 0 ? policy.entities : DEFAULT_PII_ENTITIES;
+	return new Set(list);
+}
+/**
+* Detect and mask PII in a single string.
+*
+* `mode: 'off'` is a pass-through (returns the input verbatim with no findings).
+* Replacement is applied end-to-start so finding offsets stay valid, and the
+* mask token (`<ENTITY_TYPE>`) matches no detector, keeping redaction idempotent.
+*/
+function redactPiiText(text, policy, analyzer = defaultRegexPiiAnalyzer) {
+	if (policy.mode === "off" || typeof text !== "string" || text.length === 0) return {
+		text,
+		findings: []
+	};
+	const entities = resolvePolicyEntities(policy);
+	const findings = analyzer.analyze(text, entities);
+	if (findings.length === 0) return {
+		text,
+		findings
+	};
+	let out = text;
+	for (let i = findings.length - 1; i >= 0; i--) {
+		const finding = findings[i];
+		out = out.slice(0, finding.start) + `<${finding.entityType}>` + out.slice(finding.end);
+	}
+	return {
+		text: out,
+		findings
+	};
+}
+export { redactPiiText as t };
+

package/dist/chunk-o0ygUbCf.js

@@ -0,0 +1,313 @@
+#!/usr/bin/env node
+import { t as isTTY } from "./index.js";
+import { DataList, EntityCard, MutationResult, React, Text, 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 } from "./chunk-CcFCyqbB.js";
+import { Command } from "commander";
+import chalk from "chalk";
+// src/commands/flow-versions.ts
+const flowVersionsCommand = new Command("flow-versions").description("Manage flow versions");
+flowVersionsCommand.command("list <flowId>").description("List all versions for a flow").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (flowId, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.get(`/flow-versions/${flowId}`);
+			if (options.json) printJson(data);
+			else {
+				const versions = data.data ?? [];
+				if (versions.length === 0) {
+					console.log(chalk.gray("No versions found"));
+					return;
+				}
+				console.log(chalk.cyan(`Versions for flow ${flowId}:`));
+				for (const v of versions) {
+					const publishedTag = v.published ? chalk.green(" [published]") : "";
+					const versionNum = v.version !== void 0 ? `v${v.version}` : v.id;
+					const date = v.createdAt ? chalk.gray(` ${v.createdAt}`) : "";
+					console.log(`  ${chalk.green(v.id)} ${versionNum}${publishedTag}${date}`);
+				}
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to fetch versions"));
+			console.error(chalk.red(message));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [items, setItems] = useState(null);
+		const [error, setError] = useState(null);
+		useEffect(() => {
+			const run = async () => {
+				try {
+					const data = await client.get(`/flow-versions/${flowId}`);
+					setItems(data.data ?? []);
+					setLoading(false);
+				} catch (err) {
+					setError(err instanceof Error ? err : new Error(String(err)));
+					setLoading(false);
+				}
+			};
+			run();
+		}, []);
+		return React.createElement(DataList, {
+			title: `Versions for flow ${flowId}`,
+			items,
+			error,
+			loading,
+			emptyMessage: "No versions found",
+			renderCard: (item) => {
+				const v = item;
+				const publishedTag = v.published ? " [published]" : "";
+				const versionNum = v.version !== void 0 ? `v${v.version}` : v.id;
+				return React.createElement(Text, null, `  ${v.id} ${versionNum}${publishedTag}${v.createdAt ? ` ${v.createdAt}` : ""}`);
+			}
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+flowVersionsCommand.command("get <flowId> <versionId>").description("Get a specific version").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (flowId, versionId, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.get(`/flow-versions/${flowId}/${versionId}`);
+			if (options.json) printJson(data);
+			else printDetail("Flow Version", [
+				{
+					label: "ID",
+					value: data.id
+				},
+				{
+					label: "Flow ID",
+					value: data.flowId
+				},
+				{
+					label: "Version",
+					value: data.version
+				},
+				{
+					label: "Published",
+					value: data.published
+				},
+				{
+					label: "Created",
+					value: data.createdAt
+				},
+				{
+					label: "Steps",
+					value: data.steps?.length
+				}
+			]);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to fetch version"));
+			console.error(chalk.red(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.get(`/flow-versions/${flowId}/${versionId}`);
+					setResultNode(React.createElement(EntityCard, { fields: [
+						{
+							label: "ID",
+							value: data.id
+						},
+						{
+							label: "Flow ID",
+							value: data.flowId
+						},
+						{
+							label: "Version",
+							value: data.version
+						},
+						{
+							label: "Published",
+							value: data.published ? "Yes" : "No",
+							color: data.published ? "green" : void 0
+						},
+						{
+							label: "Created",
+							value: data.createdAt
+						},
+						{
+							label: "Steps",
+							value: data.steps?.length
+						}
+					] }));
+					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 version...",
+			success,
+			successMessage: "Flow Version",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+flowVersionsCommand.command("published <flowId>").description("Get the published version for a flow").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (flowId, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.get(`/flow-versions/${flowId}/published`);
+			if (options.json) printJson(data);
+			else printDetail("Published Version", [
+				{
+					label: "ID",
+					value: data.id
+				},
+				{
+					label: "Version",
+					value: data.version
+				},
+				{
+					label: "Created",
+					value: data.createdAt
+				},
+				{
+					label: "Steps",
+					value: data.steps?.length
+				}
+			]);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to fetch published version"));
+			console.error(chalk.red(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.get(`/flow-versions/${flowId}/published`);
+					setResultNode(React.createElement(EntityCard, { fields: [
+						{
+							label: "ID",
+							value: data.id
+						},
+						{
+							label: "Version",
+							value: data.version
+						},
+						{
+							label: "Created",
+							value: data.createdAt
+						},
+						{
+							label: "Steps",
+							value: data.steps?.length
+						}
+					] }));
+					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 published version...",
+			success,
+			successMessage: "Published Version",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+flowVersionsCommand.command("publish <flowId>").description("Publish a version").requiredOption("-v, --version <versionId>", "Version ID to publish").option("--overwrite-managed", "Confirm replacing a definition managed by code").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (flowId, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	if (!isTTY(options)) {
+		try {
+			const result = await client.post(`/flow-versions/${flowId}/publish`, {
+				versionId: options.version,
+				...options.overwriteManaged ? { onConflict: "overwrite" } : {}
+			});
+			console.log(chalk.green("Version published"));
+			for (const warning of result.warnings ?? []) console.warn(chalk.yellow(`Warning: ${warning}`));
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to publish version"));
+			console.error(chalk.red(message));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [success, setSuccess] = useState(null);
+		const [error, setError] = useState(null);
+		const [successMessage, setSuccessMessage] = useState("Version published");
+		useEffect(() => {
+			const run = async () => {
+				try {
+					const result = await client.post(`/flow-versions/${flowId}/publish`, {
+						versionId: options.version,
+						...options.overwriteManaged ? { onConflict: "overwrite" } : {}
+					});
+					if (result.warnings?.length) setSuccessMessage(`Version published. ${result.warnings.join(" ")}`);
+					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: "Publishing version...",
+			success,
+			successMessage,
+			error
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+export { flowVersionsCommand };
+