@runtypelabs/cli 2.59.1 → 2.59.4

package/dist/chunk-CwM_9y01.js

@@ -0,0 +1,519 @@
+#!/usr/bin/env node
+import { t as isTTY } from "./index.js";
+import { DataList, EntityCard, MutationResult, React, render, useEffect, useState } from "./chunk-CoAWdSiE.js";
+import { p as buildDashboardUrl } from "./chunk-ucu5lrDZ.js";
+import { r as createCliClient, s as getDashboardUrl } from "./chunk-BW2fg46T.js";
+import { n as ensureAuth } from "./chunk-CJraEBVd.js";
+import { a as printJson, i as printDetail, n as buildListParams, r as getTotalCount, s as printNextCursorHint } from "./chunk-CcFCyqbB.js";
+import { t as readJsonFile } from "./chunk-DGv7X9S_.js";
+import { c as buildEntityPullCommand, d as productPullFpoCommand, r as PRODUCT_ENSURE_SPEC, s as buildEntityEnsureCommand, u as productEnsureFpoCommand } from "./chunk-BirUxTtH.js";
+import { t as getCurrentAccountId } from "./chunk-BV-8isOd.js";
+import { n as validateQuickStartUrl, t as createQuickStartProduct } from "./chunk-i7DwkvvD.js";
+import { Command } from "commander";
+import chalk from "chalk";
+import open from "open";
+// src/commands/products.ts
+function displayAgentCard(agentCard) {
+	console.log(chalk.cyan("\nAgent Details:"));
+	console.log(`  Name:        ${agentCard.name}`);
+	if (agentCard.description) console.log(`  Description: ${agentCard.description}`);
+	console.log(`  URL:         ${agentCard.url}`);
+	if (agentCard.skills && agentCard.skills.length > 0) {
+		console.log("  Skills:");
+		agentCard.skills.forEach((skill) => {
+			const desc = skill.description ? ` - ${skill.description}` : "";
+			console.log(`    ${chalk.cyan("•")} ${skill.name}${desc}`);
+		});
+	}
+}
+async function createProduct(apiKey, templateId, agentCard, sourceUrl, productName, apiUrl) {
+	return createQuickStartProduct(apiKey, {
+		templateId,
+		agentCard,
+		productName,
+		sourceUrl
+	}, apiUrl);
+}
+function displayCreationSuccess(result, agentCard, dashboardBaseUrl, jsonOutput, account) {
+	const productUrl = buildDashboardUrl({
+		baseUrl: dashboardBaseUrl,
+		path: `/products/${result.product.id}`,
+		account,
+		searchParams: { launch: "true" }
+	});
+	if (jsonOutput) {
+		console.log(JSON.stringify({
+			status: "created",
+			product: result.product,
+			agentCard,
+			dashboardUrl: productUrl
+		}, null, 2));
+		return;
+	}
+	console.log(`\nProduct ID:  ${result.product.id}`);
+	console.log(`Name:        ${result.product.name}`);
+	console.log(`Dashboard:   ${productUrl}`);
+	console.log(chalk.cyan("\nNext steps:"));
+	console.log("  1. Visit the dashboard to configure surfaces");
+	console.log("  2. Or run: runtype products init --from <another-url>");
+}
+async function validateUrl(url, apiUrl) {
+	return validateQuickStartUrl(url, apiUrl);
+}
+const productsCommand = new Command("products").description("Manage products");
+productsCommand.addCommand(buildEntityEnsureCommand(PRODUCT_ENSURE_SPEC));
+productsCommand.addCommand(buildEntityPullCommand(PRODUCT_ENSURE_SPEC));
+productsCommand.addCommand(productEnsureFpoCommand);
+productsCommand.addCommand(productPullFpoCommand);
+productsCommand.command("init").description("Initialize a product from an external resource").option("--from <url>", "URL to validate and import").option("--name <name>", "Custom product name (defaults to agent name)").option("--open", "Open browser to dashboard instead of creating via API").option("--json", "Output as JSON").option("--api-url <url>", "Override API URL").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (options) => {
+	const isJsonMode = !!options.json;
+	if (!isTTY(options) || isJsonMode) {
+		let sourceUrl = options.from;
+		if (!sourceUrl) {
+			if (isJsonMode) {
+				console.log(JSON.stringify({
+					status: "error",
+					error: "Missing --from URL",
+					code: "MISSING_URL"
+				}, null, 2));
+				process.exit(1);
+			}
+			console.error(chalk.red("--from URL required in non-TTY mode"));
+			process.exit(1);
+		}
+		try {
+			const result = await validateUrl(sourceUrl, options.apiUrl);
+			if (!result.valid) {
+				if (isJsonMode) console.log(JSON.stringify({
+					status: "error",
+					error: result.error,
+					code: result.code
+				}, null, 2));
+				else console.error(chalk.red(result.error));
+				process.exit(1);
+			}
+			displayAgentCard(result.agentCard);
+			const productName = options.name;
+			const apiKey = isJsonMode ? await getApiKeyOrExit(isJsonMode, result.agentCard) : await ensureAuth({ apiUrl: options.apiUrl });
+			if (!apiKey) process.exit(1);
+			if (options.open) {
+				const targetUrl = `${getDashboardUrl()}/now?from=${encodeURIComponent(sourceUrl)}&cli=true`;
+				if (isJsonMode) console.log(JSON.stringify({
+					status: "browser_opened",
+					agentCard: result.agentCard,
+					url: targetUrl
+				}, null, 2));
+				else console.log(chalk.cyan("\nOpening browser to complete setup..."));
+				await open(targetUrl);
+				return;
+			}
+			const createResult = await createProduct(apiKey, result.templateId, result.agentCard, sourceUrl, productName, options.apiUrl);
+			if (!createResult.success) {
+				if (isJsonMode) console.log(JSON.stringify({
+					status: "error",
+					error: createResult.error,
+					code: createResult.code
+				}, null, 2));
+				else console.error(chalk.red(createResult.error));
+				process.exit(1);
+			}
+			const account = await getCurrentAccountId();
+			displayCreationSuccess(createResult, result.agentCard, getDashboardUrl(), isJsonMode, account);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const ProductInitApp = () => {
+		const [loading, setLoading] = useState(!!options.from);
+		const [loadingLabel, setLoadingLabel] = useState("Validating URL...");
+		const [success, setSuccess] = useState(null);
+		const [error, setError] = useState(null);
+		const [resultNode, setResultNode] = useState(void 0);
+		useEffect(() => {
+			if (!options.from) return void 0;
+			const run = async () => {
+				try {
+					const result = await validateUrl(options.from, options.apiUrl);
+					if (!result.valid) {
+						setError(new Error(result.error));
+						setSuccess(false);
+						setLoading(false);
+						return;
+					}
+					const productName = options.name || result.agentCard.name;
+					const apiKey = await ensureAuth({ apiUrl: options.apiUrl });
+					if (!apiKey) {
+						setError(/* @__PURE__ */ new Error("Authentication required"));
+						setSuccess(false);
+						setLoading(false);
+						return;
+					}
+					if (options.open) {
+						const targetUrl = `${getDashboardUrl()}/now?from=${encodeURIComponent(options.from)}&cli=true`;
+						await open(targetUrl);
+						setSuccess(true);
+						setLoading(false);
+						setResultNode(React.createElement(EntityCard, { fields: [{
+							label: "Status",
+							value: "Browser opened"
+						}, {
+							label: "URL",
+							value: targetUrl
+						}] }));
+						return;
+					}
+					setLoadingLabel("Creating product...");
+					const createResult = await createProduct(apiKey, result.templateId, result.agentCard, options.from, productName, options.apiUrl);
+					if (!createResult.success) {
+						setError(new Error(createResult.error));
+						setSuccess(false);
+						setLoading(false);
+						return;
+					}
+					const dashboardUrl = getDashboardUrl();
+					const account = await getCurrentAccountId();
+					setResultNode(React.createElement(EntityCard, { fields: [
+						{
+							label: "Product ID",
+							value: createResult.product.id,
+							color: "green"
+						},
+						{
+							label: "Name",
+							value: createResult.product.name
+						},
+						{
+							label: "Dashboard",
+							value: buildDashboardUrl({
+								baseUrl: dashboardUrl,
+								path: `/products/${createResult.product.id}`,
+								account
+							})
+						}
+					] }));
+					setSuccess(true);
+					setLoading(false);
+				} catch (err) {
+					setError(err instanceof Error ? err : new Error(String(err)));
+					setSuccess(false);
+					setLoading(false);
+				}
+			};
+			run();
+		}, []);
+		if (!options.from) return React.createElement(MutationResult, {
+			loading: false,
+			success: false,
+			error: /* @__PURE__ */ new Error("Use \"runtype init\" for interactive product setup, or provide --from <url>")
+		});
+		return React.createElement(MutationResult, {
+			loading,
+			loadingLabel,
+			success,
+			successMessage: "Product Created",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(ProductInitApp));
+	await waitUntilExit();
+});
+productsCommand.command("list").description("List your products").option("--limit <n>", "Limit results (defaults to the API page size)").option("--cursor <cursor>", "Pagination cursor for the next page").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	const params = buildListParams(options);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.get("/products", params);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			const products = data.data ?? [];
+			if (products.length === 0) {
+				console.log(chalk.gray("No products found"));
+				return;
+			}
+			console.log(chalk.cyan("Your Products:"));
+			for (const p of products) {
+				const meta = `${p.capabilityCount ?? 0} capabilities, ${p.surfaceCount ?? 0} surfaces`;
+				console.log(`  ${chalk.green(p.id)} ${p.name} ${chalk.gray(`(${meta})`)}`);
+			}
+			const total = getTotalCount(data.pagination);
+			if (total !== void 0) console.log(chalk.dim(`\n  Total: ${total} products`));
+			printNextCursorHint("runtype products list", data.pagination);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to fetch products: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [items, setItems] = useState(null);
+		const [error, setError] = useState(null);
+		const [total, setTotal] = useState();
+		useEffect(() => {
+			client.get("/products", 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 Products",
+			items,
+			error,
+			loading: items === null && error === null,
+			total,
+			emptyMessage: "No products found",
+			renderCard: (item) => {
+				const p = item;
+				return React.createElement(EntityCard, { fields: [
+					{
+						label: "ID",
+						value: p.id,
+						color: "green"
+					},
+					{
+						label: "Name",
+						value: p.name
+					},
+					{
+						label: "Description",
+						value: p.description,
+						color: "gray"
+					},
+					{
+						label: "Capabilities",
+						value: p.capabilityCount
+					},
+					{
+						label: "Surfaces",
+						value: p.surfaceCount
+					}
+				] });
+			}
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+productsCommand.command("get <id>").description("Get product details").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (id, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.get(`/products/${id}`);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			printDetail("Product", [
+				{
+					label: "ID",
+					value: data.id
+				},
+				{
+					label: "Name",
+					value: data.name
+				},
+				{
+					label: "Description",
+					value: data.description
+				},
+				{
+					label: "Icon",
+					value: data.icon
+				},
+				{
+					label: "Capabilities",
+					value: data.capabilities?.length ?? 0
+				},
+				{
+					label: "Surfaces",
+					value: data.surfaces?.length ?? 0
+				},
+				{
+					label: "Created",
+					value: data.createdAt
+				},
+				{
+					label: "Updated",
+					value: data.updatedAt
+				},
+				{
+					label: "Dashboard",
+					value: data.dashboardUrl
+				}
+			]);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to fetch product: ${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(`/products/${id}`);
+					setResultNode(React.createElement(EntityCard, { fields: [
+						{
+							label: "ID",
+							value: data.id,
+							color: "green"
+						},
+						{
+							label: "Name",
+							value: data.name
+						},
+						{
+							label: "Description",
+							value: data.description,
+							color: "gray"
+						},
+						{
+							label: "Icon",
+							value: data.icon
+						},
+						{
+							label: "Capabilities",
+							value: data.capabilities?.length ?? 0
+						},
+						{
+							label: "Surfaces",
+							value: data.surfaces?.length ?? 0
+						},
+						{
+							label: "Created",
+							value: data.createdAt
+						},
+						{
+							label: "Dashboard",
+							value: data.dashboardUrl
+						}
+					] }));
+					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 product...",
+			success,
+			successMessage: "Product",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+/** Reads `{ "items": [...] }` from `--file` (or `-` for stdin), exiting with a clear error when it has no item list. */
+function readStackFile(path) {
+	const items = readJsonFile(path, { label: "stack file" }).items;
+	if (Array.isArray(items)) return items;
+	console.error(chalk.red("stack file must be a JSON object with an \"items\" array"));
+	process.exit(1);
+}
+productsCommand.command("stack").description("Manage what a product is built on, as shown on its Overview").command("declare <id>").description("Declare what the product is built on (frameworks, vector databases, services), replacing the previous CLI declaration").requiredOption("--file <path>", "JSON file with { \"items\": [{ \"key\", \"label\", ... }] }, or - for stdin").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (id, options) => {
+	const items = readStackFile(options.file);
+	if (!items) return;
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	const declare = () => client.put(`/products/${encodeURIComponent(id)}/stack/declared`, {
+		source: "cli",
+		items
+	});
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await declare();
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			console.log(chalk.green("Stack declared"));
+			console.log(`  Product: ${chalk.green(data.productId)}`);
+			console.log(`  Items: ${data.declaration.items.length}`);
+			console.log(`  Declared by: ${data.declaration.actorLabel}`);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to declare the stack: ${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(() => {
+			declare().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: "Declaring stack...",
+			success,
+			successMessage: "Stack declared",
+			error,
+			result: result ? React.createElement(EntityCard, { fields: [
+				{
+					label: "Product",
+					value: result.productId,
+					color: "green"
+				},
+				{
+					label: "Items",
+					value: result.declaration.items.map((item) => item.label).join(", ") || "None"
+				},
+				{
+					label: "Declared by",
+					value: result.declaration.actorLabel
+				}
+			] }) : void 0
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+async function getApiKeyOrExit(isJsonMode, agentCard) {
+	const { CredentialStore } = await import("./index.js").then((n) => n.x);
+	const apiKey = await new CredentialStore().getApiKey();
+	if (!apiKey) {
+		if (isJsonMode) console.log(JSON.stringify({
+			status: "unauthenticated",
+			agentCard,
+			message: "Authentication required to create product"
+		}, null, 2));
+		return null;
+	}
+	return apiKey;
+}
+export { productsCommand };
+