@runtypelabs/cli 2.59.1 → 2.59.2

package/dist/chunk-3An_BRHv.js

@@ -0,0 +1,501 @@
+#!/usr/bin/env node
+import { t as isTTY } from "./index.js";
+import { ConfirmPrompt, 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 { l as clientTokenEnsureCommand } from "./chunk-BirUxTtH.js";
+import { Command } from "commander";
+import chalk from "chalk";
+// src/commands/client-tokens.ts
+const clientTokensCommand = new Command("client-tokens").description("Manage client tokens for Persona widget embedding");
+clientTokensCommand.command("list").description("List your client tokens").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("/client-tokens");
+			const tokens = data.clientTokens ?? [];
+			if (options.json) printJson(data);
+			else {
+				if (tokens.length === 0) {
+					console.log(chalk.gray("No client tokens found"));
+					return;
+				}
+				console.log(chalk.cyan("Your Client Tokens:"));
+				for (const token of tokens) {
+					const env = token.environment === "live" ? chalk.green("live") : chalk.yellow("test");
+					const active = token.isActive ? "" : chalk.red(" (inactive)");
+					const origins = chalk.gray(` origins: ${(token.allowedOrigins || []).join(", ")}`);
+					console.log(`  ${chalk.green(token.id)} ${token.name} [${env}]${active}${origins}`);
+				}
+				console.log(chalk.dim(`\n  Total: ${tokens.length} tokens`));
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to fetch client tokens"));
+			console.error(chalk.red(message));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [items, setItems] = useState(null);
+		const [total, setTotal] = useState(void 0);
+		const [error, setError] = useState(null);
+		useEffect(() => {
+			const run = async () => {
+				try {
+					const tokens = (await client.get("/client-tokens")).clientTokens ?? [];
+					setItems(tokens);
+					setTotal(tokens.length);
+					setLoading(false);
+				} catch (err) {
+					setError(err instanceof Error ? err : new Error(String(err)));
+					setLoading(false);
+				}
+			};
+			run();
+		}, []);
+		return React.createElement(DataList, {
+			title: "Your Client Tokens",
+			items,
+			error,
+			loading,
+			total,
+			emptyMessage: "No client tokens found",
+			renderCard: (item) => {
+				const t = item;
+				const env = t.environment === "live" ? "live" : "test";
+				const active = t.isActive ? "" : " (inactive)";
+				return React.createElement(Text, null, `  ${t.id} ${t.name} [${env}]${active}`);
+			}
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+clientTokensCommand.command("get <id>").description("Get client token 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(`/client-tokens/${id}`);
+			const token = data.clientToken;
+			if (options.json) printJson(data);
+			else printDetail("Client Token", [
+				{
+					label: "ID",
+					value: token.id
+				},
+				{
+					label: "Name",
+					value: token.name
+				},
+				{
+					label: "Environment",
+					value: token.environment
+				},
+				{
+					label: "Active",
+					value: token.isActive
+				},
+				{
+					label: "Token Value",
+					value: token.tokenValue
+				},
+				{
+					label: "Flow IDs",
+					value: (token.flowIds || []).join(", ") || null
+				},
+				{
+					label: "Default Flow ID",
+					value: token.defaultFlowId
+				},
+				{
+					label: "Agent IDs",
+					value: (token.agentIds || []).join(", ") || null
+				},
+				{
+					label: "Allowed Origins",
+					value: (token.allowedOrigins || []).join(", ")
+				},
+				{
+					label: "Rate Limit/min",
+					value: token.rateLimitPerMinute
+				},
+				{
+					label: "Rate Limit/hr",
+					value: token.rateLimitPerHour
+				},
+				{
+					label: "Max Messages/Session",
+					value: token.maxMessagesPerSession
+				},
+				{
+					label: "Session Timeout (min)",
+					value: token.sessionIdleTimeoutMinutes
+				},
+				{
+					label: "Conversations",
+					value: token.conversationCount
+				},
+				{
+					label: "Last Used",
+					value: token.lastUsedAt
+				},
+				{
+					label: "Created",
+					value: token.createdAt
+				}
+			]);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to fetch client token"));
+			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 token = (await client.get(`/client-tokens/${id}`)).clientToken;
+					setResultNode(React.createElement(EntityCard, { fields: [
+						{
+							label: "ID",
+							value: token.id
+						},
+						{
+							label: "Name",
+							value: token.name
+						},
+						{
+							label: "Environment",
+							value: token.environment
+						},
+						{
+							label: "Active",
+							value: String(token.isActive)
+						},
+						{
+							label: "Token Value",
+							value: token.tokenValue
+						},
+						{
+							label: "Flow IDs",
+							value: (token.flowIds || []).join(", ") || null
+						},
+						{
+							label: "Agent IDs",
+							value: (token.agentIds || []).join(", ") || null
+						},
+						{
+							label: "Allowed Origins",
+							value: (token.allowedOrigins || []).join(", ")
+						},
+						{
+							label: "Last Used",
+							value: token.lastUsedAt
+						},
+						{
+							label: "Created",
+							value: token.createdAt
+						}
+					] }));
+					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 client token...",
+			success,
+			successMessage: "Client Token",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+clientTokensCommand.command("create").description("Create a new client token").requiredOption("-n, --name <name>", "Token name").option("--origins <origins...>", "Allowed origins (e.g. https://example.com). Defaults to * (all origins)").option("--environment <env>", "Token environment: test or live", "test").option("--flow-ids <ids...>", "Flow IDs to associate").option("--default-flow-id <id>", "Default flow ID (required when flow-ids provided)").option("--agent-ids <ids...>", "Agent IDs to associate").option("--target-alias <name>", "Release alias this token follows for its agent target").option("--target-version-id <id>", "Exact agent version this token pins").option("--rate-limit-per-minute <n>", "Rate limit per minute", "10").option("--rate-limit-per-hour <n>", "Rate limit per hour", "100").option("--max-messages <n>", "Max messages per session", "100").option("--session-timeout <n>", "Session idle timeout in minutes", "30").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (options) => {
+	const flowIds = options.flowIds || [];
+	const agentIds = options.agentIds || [];
+	if (flowIds.length === 0 && agentIds.length === 0) {
+		console.error(chalk.red("Error: At least one --flow-ids or --agent-ids is required"));
+		process.exit(1);
+	}
+	if (flowIds.length > 0 && !options.defaultFlowId) {
+		console.error(chalk.red("Error: --default-flow-id is required when --flow-ids is provided"));
+		process.exit(1);
+	}
+	if (!["test", "live"].includes(options.environment)) {
+		console.error(chalk.red("Error: --environment must be \"test\" or \"live\""));
+		process.exit(1);
+	}
+	if (options.targetAlias && options.targetVersionId) {
+		console.error(chalk.red("Error: provide at most one of --target-alias or --target-version-id"));
+		process.exit(1);
+	}
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	const body = {
+		name: options.name,
+		flowIds,
+		defaultFlowId: options.defaultFlowId,
+		agentIds,
+		...options.targetAlias ? { targetAlias: options.targetAlias } : {},
+		...options.targetVersionId ? { targetVersionId: options.targetVersionId } : {},
+		allowedOrigins: options.origins || ["*"],
+		environment: options.environment,
+		rateLimitPerMinute: parseInt(options.rateLimitPerMinute, 10),
+		rateLimitPerHour: parseInt(options.rateLimitPerHour, 10),
+		maxMessagesPerSession: parseInt(options.maxMessages, 10),
+		sessionIdleTimeoutMinutes: parseInt(options.sessionTimeout, 10)
+	};
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.post("/client-tokens", body);
+			if (options.json) printJson(data);
+			else {
+				const token = data.clientToken;
+				console.log(chalk.green("Client token created"));
+				console.log(`  ID: ${chalk.green(token.id)}`);
+				console.log(`  Name: ${token.name}`);
+				console.log(`  Environment: ${token.environment}`);
+				console.log(`  Token: ${chalk.yellow(data.token)}`);
+				if (data.warnings?.length > 0) {
+					console.log("");
+					for (const w of data.warnings) console.log(chalk.yellow(`  ⚠ ${w.message}`));
+				}
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to create client token"));
+			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.post("/client-tokens", body);
+					const fields = [
+						{
+							label: "ID",
+							value: data.clientToken.id,
+							color: "green"
+						},
+						{
+							label: "Name",
+							value: data.clientToken.name
+						},
+						{
+							label: "Environment",
+							value: data.clientToken.environment
+						},
+						{
+							label: "Token",
+							value: data.token,
+							color: "yellow"
+						}
+					];
+					if (data.warnings?.length > 0) for (const w of data.warnings) fields.push({
+						label: "Warning",
+						value: w.message,
+						color: "yellow"
+					});
+					setResultNode(React.createElement(EntityCard, { fields }));
+					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: "Creating client token...",
+			success,
+			successMessage: "Client token created",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+clientTokensCommand.command("delete <id>").description("Delete a client token").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").option("--yes", "Skip confirmation").action(async (id, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	if (!isTTY(options)) {
+		try {
+			await client.clientTokens.delete(id);
+			console.log(chalk.green("Client token deleted"));
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to delete client token"));
+			console.error(chalk.red(message));
+			process.exit(1);
+		}
+		return;
+	}
+	if (options.yes) {
+		const App = () => {
+			const [loading, setLoading] = useState(true);
+			const [success, setSuccess] = useState(null);
+			const [error, setError] = useState(null);
+			useEffect(() => {
+				const run = async () => {
+					try {
+						await client.clientTokens.delete(id);
+						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 client token...",
+				success,
+				successMessage: "Client token deleted",
+				error
+			});
+		};
+		const { waitUntilExit } = render(React.createElement(App));
+		await waitUntilExit();
+		return;
+	}
+	if (!await new Promise((resolve) => {
+		const { unmount } = render(React.createElement(ConfirmPrompt, {
+			message: `Delete client token ${id}?`,
+			defaultValue: false,
+			onConfirm: (result) => {
+				resolve(result);
+				unmount();
+			}
+		}));
+	})) return;
+	const DeleteApp = () => {
+		const [loading, setLoading] = useState(true);
+		const [success, setSuccess] = useState(null);
+		const [error, setError] = useState(null);
+		useEffect(() => {
+			const run = async () => {
+				try {
+					await client.clientTokens.delete(id);
+					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 client token...",
+			success,
+			successMessage: "Client token deleted",
+			error
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(DeleteApp));
+	await waitUntilExit();
+});
+clientTokensCommand.command("regenerate <id>").description("Regenerate a client token (invalidates the old token)").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.post(`/client-tokens/${id}/regenerate`);
+			if (options.json) printJson(data);
+			else {
+				console.log(chalk.green("Client token regenerated"));
+				console.log(`  New Token: ${chalk.yellow(data.token)}`);
+				console.log(chalk.gray("  Previous token is now invalid. Update your client-side code."));
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to regenerate client token"));
+			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.post(`/client-tokens/${id}/regenerate`);
+					setResultNode(React.createElement(EntityCard, { fields: [{
+						label: "New Token",
+						value: data.token,
+						color: "yellow"
+					}, {
+						label: "Note",
+						value: "Previous token is now invalid. Update your client-side code."
+					}] }));
+					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: "Regenerating client token...",
+			success,
+			successMessage: "Client token regenerated",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+clientTokensCommand.addCommand(clientTokenEnsureCommand);
+export { clientTokensCommand };
+