@runtypelabs/cli 2.59.1 → 2.59.4

package/dist/chunk-BW2fg46T.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+import { F as getCliVersion, l as normalizeApiUrl, o as getEffectiveApiUrl, r as assertCliClientTarget } from "./index.js";
+import { RuntypeApiError, createClient } from "@runtypelabs/sdk";
+// src/config/env.ts
+function getApiUrl() {
+	return getEffectiveApiUrl();
+}
+function getApiVersion() {
+	return process.env.RUNTYPE_API_VERSION || "v1";
+}
+function getDashboardUrl() {
+	return process.env.RUNTYPE_DASHBOARD_URL || "https://use.runtype.com";
+}
+function getClerkPublishableKey() {
+	return process.env.CLERK_PUBLISHABLE_KEY || "pk_live_default_key";
+}
+function getRuntimeApiKey() {
+	return process.env.RUNTYPE_API_KEY;
+}
+function getDevPlanOverride() {
+	return process.env.RUNTYPE_DEV_PLAN_OVERRIDE;
+}
+// src/lib/sdk-client.ts
+/**
+* Construct the SDK client used by every CLI command for API access.
+* The SDK is the single source of truth for the API surface; do NOT reintroduce raw fetch (enforced by `runtype/cli-use-sdk`).
+* Reproduces the headers the CLI has always sent: client identification, versioned User-Agent, and optional dev plan override.
+*/
+function createCliClient(apiKey, baseUrl) {
+	const devOverride = getDevPlanOverride();
+	const resolvedApiUrl = normalizeApiUrl(baseUrl || getApiUrl());
+	assertCliClientTarget(apiKey, resolvedApiUrl);
+	return createClient({
+		apiKey,
+		baseUrl: resolvedApiUrl,
+		apiVersion: getApiVersion(),
+		timeout: null,
+		headers: {
+			"X-Runtype-Client": "cli",
+			"User-Agent": `runtype-cli/${getCliVersion()}`,
+			"X-Runtype-CLI-Version": getCliVersion(),
+			...devOverride ? { "X-Dev-Plan-Override": devOverride } : {}
+		}
+	});
+}
+// src/auth/api-key-manager.ts
+const isCliTokenResponse = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.apiKey === "string" && typeof record.userId === "string";
+};
+const isAuthMeResponse = (value) => {
+	if (!value || typeof value !== "object") return false;
+	return typeof value.userId === "string";
+};
+/**
+* The key could not be checked at all — nothing on the path ever said the
+* credentials were bad. Kept distinct from `validateApiKey` returning false so
+* callers stop telling people their key is invalid when the real problem is
+* that an egress proxy, firewall, or outage sits between them and the API.
+*/
+var ApiKeyValidationUnavailableError = class extends Error {
+	statusCode;
+	constructor(message, statusCode, options) {
+		super(message, options);
+		this.statusCode = statusCode;
+		this.name = "ApiKeyValidationUnavailableError";
+	}
+};
+const describeUnverifiableStatus = (statusCode, apiUrl) => {
+	const answered = `Could not verify the API key: the API at ${apiUrl} answered HTTP ${statusCode}`;
+	if (statusCode === 403 || statusCode === 407) return `${answered} (this can be an egress proxy or firewall blocking ${apiUrl}, not an invalid key)`;
+	if (statusCode >= 500) return `${answered} (the API or something in front of it is failing, not an invalid key). Try again shortly.`;
+	return `${answered}, which is neither a success nor a credential rejection, so the key was not verified.`;
+};
+var ApiKeyManager = class {
+	/**
+	* Exchange a Clerk session JWT for a persistent API key.
+	*
+	* Calls POST /v1/auth/cli-token on the Runtype API directly,
+	* passing the Clerk JWT as a Bearer token. The API verifies the JWT
+	* with Clerk and creates an API key for the CLI.
+	*/
+	async exchangeSessionForApiKey(clerkJwt, apiUrl) {
+		const client = createCliClient(clerkJwt, apiUrl);
+		let data;
+		try {
+			data = await client.post("/auth/cli-token");
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new Error(`Authentication failed: ${message}`, { cause: error });
+		}
+		if (!isCliTokenResponse(data)) throw new Error("Invalid authentication response format");
+		const result = {
+			key: data.apiKey,
+			userId: data.userId
+		};
+		if (data.orgId) result.orgId = data.orgId;
+		return result;
+	}
+	/**
+	* Resolve whether the API accepts this key.
+	* `false` means the API explicitly rejected the credentials; anything unresolved throws.
+	* Returning false for every non-2xx response used to misreport a proxy 403/407 or API 5xx as an invalid key.
+	*/
+	async validateApiKey(apiKey, apiUrl) {
+		const resolvedApiUrl = apiUrl || getApiUrl();
+		const client = createCliClient(apiKey, resolvedApiUrl);
+		try {
+			await client.get("/users/profile");
+			return true;
+		} catch (error) {
+			if (error instanceof RuntypeApiError) {
+				if (error.statusCode === 401) return false;
+				throw new ApiKeyValidationUnavailableError(describeUnverifiableStatus(error.statusCode, resolvedApiUrl), error.statusCode, { cause: error });
+			}
+			throw error;
+		}
+	}
+	async getCurrentUser(apiKey, apiUrl) {
+		const client = createCliClient(apiKey, apiUrl);
+		let data;
+		try {
+			data = await client.get("/auth/me");
+		} catch {
+			try {
+				const profile = await client.get("/users/profile");
+				if (typeof profile.id === "string") data = {
+					userId: profile.id,
+					orgId: profile.orgId ?? null,
+					email: profile.email
+				};
+			} catch {}
+			if (!data) throw new Error("Failed to get user information");
+		}
+		if (!isAuthMeResponse(data)) throw new Error("Invalid user response format");
+		return data;
+	}
+};
+export { getApiVersion as a, getDevPlanOverride as c, getApiUrl as i, getRuntimeApiKey as l, ApiKeyValidationUnavailableError as n, getClerkPublishableKey as o, createCliClient as r, getDashboardUrl as s, ApiKeyManager as t };
+

package/dist/chunk-BWJdY5Ag.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { v as managedDeploymentCreateRequestSchema } from "./chunk-ucu5lrDZ.js";
+import { r as createCliClient } from "./chunk-BW2fg46T.js";
+import { n as ensureAuth } from "./chunk-CJraEBVd.js";
+import { a as printJson } from "./chunk-CcFCyqbB.js";
+import { Command } from "commander";
+import { readFile } from "node:fs/promises";
+// src/commands/sandbox-deployments.ts
+const sandboxDeploymentsCommand = new Command("sandbox-deployments").description("Author managed deployments using retained runtime profiles and uploaded source IDs");
+async function run(action) {
+	try {
+		const apiKey = await ensureAuth();
+		if (!apiKey) return;
+		printJson(await action(createCliClient(apiKey)));
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : String(error));
+		process.exitCode = 1;
+	}
+}
+sandboxDeploymentsCommand.command("runtime-profiles").description("List retained profiles and admission information for this environment").action(() => run((client) => client.sandboxDeployments.runtimeProfiles()));
+sandboxDeploymentsCommand.command("definition <id>").description("Read canonical config and advanced spec from the accepted revision").action((id) => run((client) => client.sandboxDeployments.definition(id)));
+sandboxDeploymentsCommand.command("create").description("Accept a config or advanced spec; the response does not indicate readiness").requiredOption("-f, --file <path>", "JSON request containing exactly one of config or spec").requiredOption("--idempotency-key <key>", "Reuse this key and file when retrying the request").action((options) => run(async (client) => {
+	const request = JSON.parse(await readFile(options.file, "utf8"));
+	managedDeploymentCreateRequestSchema.parse(request);
+	return client.sandboxDeployments.create(request, { idempotencyKey: options.idempotencyKey });
+}));
+sandboxDeploymentsCommand.command("update <id>").description("Replace the complete config or spec without renewing retention").requiredOption("-f, --file <path>", "JSON request containing exactly one of config or spec").requiredOption("--idempotency-key <key>", "Reuse this key and file when retrying the request").requiredOption("--if-match <version>", "Resource version from deployment definition readback").action((id, options) => run(async (client) => {
+	const request = JSON.parse(await readFile(options.file, "utf8"));
+	managedDeploymentCreateRequestSchema.parse(request);
+	return client.sandboxDeployments.update(id, request, {
+		idempotencyKey: options.idempotencyKey,
+		ifMatch: options.ifMatch
+	});
+}));
+export { sandboxDeploymentsCommand };
+

package/dist/chunk-BYJOrLhh.js

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+import { t as isTTY } from "./index.js";
+import { 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, r as getTotalCount } from "./chunk-CcFCyqbB.js";
+import { Command } from "commander";
+import chalk from "chalk";
+// src/commands/models.ts
+const modelsCommand = new Command("models").description("Manage model configurations");
+modelsCommand.command("list").description("List your enabled model configurations").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);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.get("/model-configs");
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			const models = data.data ?? [];
+			if (models.length === 0) {
+				console.log("No model configurations found");
+				return;
+			}
+			console.log("Your Models:");
+			for (const model of models) {
+				const defaultTag = model.isDefault ? " (default)" : "";
+				const statusTag = model.enabled === false ? " [disabled]" : "";
+				console.log(`  ${model.id} ${model.modelId}${defaultTag}${statusTag}`);
+			}
+			const total = getTotalCount(data.pagination);
+			if (total !== void 0) console.log(`\n  Total: ${total} models`);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to fetch models: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [items, setItems] = useState(null);
+		const [error, setError] = useState(null);
+		const [total, setTotal] = useState();
+		useEffect(() => {
+			client.get("/model-configs").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 Models",
+			items,
+			error,
+			loading: items === null && error === null,
+			total,
+			renderCard: (item) => {
+				const model = item;
+				return React.createElement(EntityCard, { fields: [
+					{
+						label: "ID",
+						value: model.id,
+						color: "green"
+					},
+					{
+						label: "Model",
+						value: model.modelId
+					},
+					{
+						label: "Default",
+						value: model.isDefault ? "yes" : null,
+						color: "yellow"
+					},
+					{
+						label: "Enabled",
+						value: model.enabled === false ? "no" : null
+					}
+				] });
+			},
+			emptyMessage: "No model configurations found"
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+modelsCommand.command("available").description("List all available models grouped by provider").option("--search <query>", "Only models matching every word, ordered by relevance").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 groupedPath = options.search ? `/model-configs/grouped?q=${encodeURIComponent(options.search)}` : "/model-configs/grouped";
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.get(groupedPath);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			const groups = data.data ?? [];
+			if (groups.length === 0) {
+				console.log("No models available");
+				return;
+			}
+			console.log("Available Models:");
+			for (const group of groups) {
+				console.log(`\n  ${group.provider} / ${group.baseModel}`);
+				for (const variant of group.variants) {
+					const configuredTag = variant.configured ? " [configured]" : "";
+					console.log(`    ${variant.modelId}${configuredTag}`);
+				}
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to fetch available models: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [items, setItems] = useState(null);
+		const [error, setError] = useState(null);
+		useEffect(() => {
+			client.get(groupedPath).then((res) => setItems(res.data ?? [])).catch((err) => setError(err instanceof Error ? err : new Error(String(err))));
+		}, []);
+		return React.createElement(DataList, {
+			title: "Available Models",
+			items,
+			error,
+			loading: items === null && error === null,
+			renderCard: (item) => {
+				const group = item;
+				return React.createElement(EntityCard, {
+					title: `${group.provider} / ${group.baseModel}`,
+					fields: group.variants.map((v) => ({
+						label: v.modelId,
+						value: v.configured ? "configured" : "available",
+						color: v.configured ? "green" : void 0
+					}))
+				});
+			},
+			emptyMessage: "No models available"
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+modelsCommand.command("enable <modelId>").description("Enable a model by creating a configuration").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (modelId, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.post("/model-configs", { modelId });
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			console.log(`  Config ID: ${data.id}`);
+			console.log(`  Model: ${data.modelId}`);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to enable model: ${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("/model-configs", { modelId }).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: `Enabling model ${modelId}...`,
+			success,
+			successMessage: "Model enabled",
+			error,
+			result: result ? React.createElement(EntityCard, { fields: [{
+				label: "ID",
+				value: result.id,
+				color: "green"
+			}, {
+				label: "Model",
+				value: result.modelId
+			}] }) : void 0
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+modelsCommand.command("disable <id>").description("Disable a model configuration").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.patch(`/model-configs/${id}/status`, { enabled: false });
+			console.log(JSON.stringify({
+				status: "disabled",
+				id
+			}, null, 2));
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to disable model: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [success, setSuccess] = useState(null);
+		const [error, setError] = useState(null);
+		useEffect(() => {
+			client.patch(`/model-configs/${id}/status`, { enabled: false }).then(() => {
+				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: "Disabling model...",
+			success,
+			successMessage: "Model disabled",
+			error
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+modelsCommand.command("default <id>").description("Set a model configuration as default").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.patch(`/model-configs/${id}/default`, {});
+			console.log(JSON.stringify({
+				status: "updated",
+				id
+			}, null, 2));
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to set default model: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [success, setSuccess] = useState(null);
+		const [error, setError] = useState(null);
+		useEffect(() => {
+			client.patch(`/model-configs/${id}/default`, {}).then(() => {
+				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: "Setting default model...",
+			success,
+			successMessage: "Default model updated",
+			error
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+modelsCommand.command("usage").description("Show model usage statistics").option("--json", "Output as JSON").action(async () => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	console.log(chalk.gray("Fetching model usage..."));
+	try {
+		const data = await createCliClient(apiKey).get("/model-configs/usage");
+		printJson(data);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		console.error(chalk.red(`Failed to fetch model usage: ${message}`));
+		process.exit(1);
+	}
+});
+export { modelsCommand };
+

package/dist/chunk-BYab8EVL.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+import { c as mergeZodSchemaAndSemantic, l as validateFPO, o as coerceFullProductObjectForSemanticValidation, s as fullProductObjectSchema, u as validateFPOTemplate } from "./chunk-6uTxgdiY.js";
+import { a as printJson } from "./chunk-CcFCyqbB.js";
+import { Command, Option } from "commander";
+import chalk from "chalk";
+import { readFileSync } from "fs";
+// src/commands/validate-product.ts
+function createValidateProductCommand() {
+	return new Command("validate-product").description("Validate a product (FPO) or FPO template locally (no API call)").argument("[input]", "Path to JSON file, raw JSON string (starts with \"{\"), or \"-\" for stdin").option("--template", "Force FPO template validation").option("--fpo", "Force FPO (non-template) validation").addOption(new Option("--json", "Output the full validation result as JSON").default(void 0)).option("-q, --quiet", "Suppress output; rely on exit code only").addHelpText("after", `\nExamples:\n  $ runtype validate-product ./my-product.json\n  $ runtype validate-product '{"version":"1.0",...}'\n  $ cat template.json | runtype validate-product -\n  $ runtype validate-product ./tpl.json --template --json\n\nExit codes:\n  0  Valid (no errors)\n  1  Invalid (errors present) or input/IO failure\n`).action(runValidateAction);
+}
+const validateProductCommand = createValidateProductCommand();
+async function runValidateAction(input, _options) {
+	const options = this.optsWithGlobals();
+	if (options.template && options.fpo) {
+		console.error(chalk.red("Error: --template and --fpo are mutually exclusive"));
+		process.exit(1);
+	}
+	let raw;
+	try {
+		raw = await readInput(input);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		console.error(chalk.red(`Failed to read input: ${message}`));
+		process.exit(1);
+		return;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		console.error(chalk.red(`Invalid JSON: ${message}`));
+		process.exit(1);
+		return;
+	}
+	const kind = options.template ? "template" : options.fpo ? "fpo" : detectKind(parsed);
+	const result = runValidation(parsed, kind);
+	const hasErrors = hasAnyErrors(result);
+	result.valid = !hasErrors;
+	if (options.quiet) {
+		process.exit(hasErrors ? 1 : 0);
+		return;
+	}
+	if (options.json) printJson(result);
+	else printHumanResult(kind, result);
+	process.exit(hasErrors ? 1 : 0);
+}
+function hasAnyErrors(result) {
+	if (result.errors.length > 0) return true;
+	if (result.kind === "template") {
+		if (result.defaultsValidation.errors.filter((e) => e.code !== "MISSING_TEMPLATE_VARIABLE").length > 0) return true;
+	}
+	return false;
+}
+async function readInput(input) {
+	if (!input || input === "-") return await readStdin();
+	const trimmed = input.trim();
+	if (trimmed.startsWith("{") || trimmed.startsWith("[")) return trimmed;
+	return readFileSync(input, "utf-8");
+}
+async function readStdin() {
+	if (process.stdin.isTTY) throw new Error("No input provided. Pass a file path, raw JSON, or pipe JSON on stdin.");
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	const data = Buffer.concat(chunks).toString("utf-8");
+	if (data.trim().length === 0) throw new Error("No input provided. Pass a file path, raw JSON, or pipe JSON on stdin.");
+	return data;
+}
+function detectKind(body) {
+	if (body && typeof body === "object" && !Array.isArray(body)) {
+		const obj = body;
+		if ("productObject" in obj && "template" in obj) return "template";
+	}
+	return "fpo";
+}
+function runValidation(body, kind) {
+	if (kind === "template") return {
+		kind,
+		...validateFPOTemplate(body)
+	};
+	const parsed = fullProductObjectSchema.safeParse(body);
+	if (!parsed.success) return {
+		kind,
+		...mergeZodSchemaAndSemantic(parsed, coerceFullProductObjectForSemanticValidation(body), validateFPO)
+	};
+	return {
+		kind,
+		...validateFPO(parsed.data)
+	};
+}
+function printHumanResult(kind, result) {
+	const label = kind === "template" ? "FPO template" : "FPO";
+	const headline = !hasAnyErrors(result) ? chalk.green(`✓ Valid ${label}`) : chalk.red(`✗ Invalid ${label}`);
+	console.log(headline);
+	console.log(chalk.gray(`  ${result.errors.length} error(s), ${result.warnings.length} warning(s), ${result.recommendations.length} recommendation(s)`));
+	printIssues("Errors", result.errors, chalk.red);
+	printIssues("Warnings", result.warnings, chalk.yellow);
+	printIssues("Recommendations", result.recommendations, chalk.blue);
+	if (result.kind === "template") {
+		const defaults = result.defaultsValidation;
+		const structuralErrors = defaults.errors.filter((e) => e.code !== "MISSING_TEMPLATE_VARIABLE");
+		const missingVars = defaults.errors.filter((e) => e.code === "MISSING_TEMPLATE_VARIABLE");
+		if (structuralErrors.length > 0) {
+			console.log();
+			console.log(chalk.red(`Defaults validation: template defaults do not produce a valid FPO`));
+			printIssues("Default-resolution errors", structuralErrors, chalk.red);
+			printIssues("Default-resolution warnings", defaults.warnings, chalk.yellow);
+		}
+		if (missingVars.length > 0) {
+			console.log();
+			console.log(chalk.gray(`Template variables needing deploy-time values (${missingVars.length}):`));
+			for (const issue of missingVars) console.log(chalk.gray(`  • ${issue.path} — ${issue.message}`));
+		}
+	}
+}
+function printIssues(title, issues, color) {
+	if (issues.length === 0) return;
+	console.log();
+	console.log(color(`${title}:`));
+	for (const issue of issues) {
+		const pathLabel = issue.path ? chalk.gray(` [${issue.path}]`) : "";
+		console.log(`  ${color("•")} ${chalk.bold(issue.code)}${pathLabel} ${issue.message}`);
+		if (issue.suggestedFix) console.log(`    ${chalk.gray("fix:")} ${issue.suggestedFix}`);
+	}
+}
+export { validateProductCommand };
+

package/dist/chunk-BfEKvp7h.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import { b as CredentialStore, t as isTTY } from "./index.js";
+import { React, render } from "./chunk-CoAWdSiE.js";
+import { i as getApiUrl, n as ApiKeyValidationUnavailableError, t as ApiKeyManager } from "./chunk-BW2fg46T.js";
+import { Command } from "commander";
+// src/commands/init.ts
+const initCommand = new Command("init").description("Set up Runtype CLI with guided onboarding").option("--api-url <url>", "Custom API URL").option("--api-key <key>", "API key for non-interactive setup").option("--name <name>", "Product name for non-interactive setup").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (options) => {
+	if (!isTTY(options)) {
+		if (!options.apiKey) {
+			console.error(JSON.stringify({
+				status: "error",
+				error: "Missing --api-key flag for non-interactive mode"
+			}, null, 2));
+			process.exit(1);
+		}
+		try {
+			const apiKeyManager = new ApiKeyManager();
+			if (!await apiKeyManager.validateApiKey(options.apiKey, options.apiUrl)) {
+				console.error(JSON.stringify({
+					status: "error",
+					error: "Invalid API key"
+				}, null, 2));
+				process.exit(1);
+			}
+			const userData = await apiKeyManager.getCurrentUser(options.apiKey, options.apiUrl);
+			await new CredentialStore().saveCredentials({
+				apiKey: options.apiKey,
+				userId: userData.userId,
+				orgId: userData.orgId ?? void 0,
+				apiUrl: options.apiUrl || getApiUrl()
+			});
+			console.log(JSON.stringify({
+				status: "authenticated",
+				userId: userData.userId,
+				orgId: userData.orgId
+			}, null, 2));
+		} catch (error) {
+			if (error instanceof ApiKeyValidationUnavailableError) {
+				console.error(JSON.stringify({
+					status: "error",
+					code: "api_unreachable",
+					error: error.message,
+					next: "If egress is restricted, allowlist api.runtype.com (staging: api.runtype-staging.com), then re-run: runtype init --api-key <key>"
+				}, null, 2));
+				process.exit(1);
+			}
+			const message = error instanceof Error ? error.message : "Authentication failed";
+			console.error(JSON.stringify({
+				status: "error",
+				error: message
+			}, null, 2));
+			process.exit(1);
+		}
+		return;
+	}
+	if (options.apiKey) try {
+		const apiKeyManager = new ApiKeyManager();
+		if (!await apiKeyManager.validateApiKey(options.apiKey, options.apiUrl)) {
+			console.error("Invalid API key");
+			process.exit(1);
+		}
+		const userData = await apiKeyManager.getCurrentUser(options.apiKey, options.apiUrl);
+		await new CredentialStore().saveCredentials({
+			apiKey: options.apiKey,
+			userId: userData.userId,
+			orgId: userData.orgId ?? void 0,
+			apiUrl: options.apiUrl || getApiUrl()
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Authentication failed";
+		console.error(message);
+		process.exit(1);
+	}
+	const { InitApp } = await import("./chunk-DwDWqSxM.js");
+	const { waitUntilExit } = render(React.createElement(InitApp, {
+		apiUrl: options.apiUrl,
+		onComplete: () => {}
+	}), { exitOnCtrlC: false });
+	await waitUntilExit();
+});
+export { initCommand };
+