@runtypelabs/cli 2.59.0 → 2.59.2

package/dist/chunk-CJraEBVd.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+import { c as loadEffectiveContext, d as useStoredCredential, f as verifyExpectedIdentity, i as assertExpectedApiUrl, n as CliContextError, s as getInvocationOptions } from "./index.js";
+import { n as ApiKeyValidationUnavailableError, t as ApiKeyManager } from "./chunk-BW2fg46T.js";
+import { n as browserLogin, r as orgMismatchWarning } from "./chunk-BnWhIqW1.js";
+import chalk from "chalk";
+import readline from "readline";
+// src/lib/ensure-auth.ts
+const verifiedUsers = /* @__PURE__ */ new WeakMap();
+async function getAuthenticatedUser() {
+	const context = await loadEffectiveContext();
+	if (!context.apiKey) throw new CliContextError("Authentication required.", "AUTH_REQUIRED");
+	const cached = verifiedUsers.get(context);
+	if (cached) return cached;
+	const apiKey = context.apiKey;
+	const user = await verifyExpectedIdentity(context, () => new ApiKeyManager().getCurrentUser(apiKey, context.apiUrl));
+	verifiedUsers.set(context, user);
+	return user;
+}
+async function assertExpectedOrganization() {
+	if (getInvocationOptions().expectOrg === void 0) return;
+	await getAuthenticatedUser();
+}
+/**
+* Inline readline-based prompt for confirm (y/n).
+* Used here instead of interactive.ts so we can delete that file.
+*/
+async function promptConfirm(message, options) {
+	const defaultYes = options?.default !== false;
+	const hint = defaultYes ? "Y/n" : "y/N";
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout,
+		terminal: true
+	});
+	return new Promise((resolve) => {
+		rl.question(chalk.cyan(`${message} (${hint}): `), (answer) => {
+			rl.close();
+			const trimmed = answer.trim().toLowerCase();
+			if (trimmed === "") resolve(defaultYes);
+			else resolve(trimmed === "y" || trimmed === "yes");
+		});
+	});
+}
+/**
+* Ensure the user is authenticated, offering interactive login if not.
+* Returns the API key on success, or null if the user declines to authenticate.
+* Checks in order: RUNTYPE_API_KEY env var, stored credentials, then interactive browser login.
+* When `exitOnFailure` is true (default) the process exits with code 1 if authentication is declined.
+*/
+async function ensureAuth(options) {
+	const context = await loadEffectiveContext(options?.apiUrl);
+	const invocation = getInvocationOptions();
+	const strictIdentity = invocation.expectApiUrl !== void 0 || invocation.expectOrg !== void 0;
+	assertExpectedApiUrl(context.apiUrl);
+	if (context.credentialSource === "environment" && context.apiKey) {
+		if (invocation.expectOrg !== void 0) {
+			await assertExpectedOrganization();
+			return context.apiKey;
+		}
+		try {
+			if (await new ApiKeyManager().validateApiKey(context.apiKey, context.apiUrl)) return context.apiKey;
+		} catch (error) {
+			if (strictIdentity) throw new CliContextError("Cannot verify RUNTYPE_API_KEY for the expected target.", "AUTH_REQUIRED");
+			if (error instanceof ApiKeyValidationUnavailableError) console.error(chalk.yellow(`\n${error.message}`));
+		}
+		if (strictIdentity) throw new CliContextError("RUNTYPE_API_KEY was rejected for the expected target.", "AUTH_REQUIRED");
+		useStoredCredential(context);
+	}
+	if (context.apiKey) {
+		await assertExpectedOrganization();
+		return context.apiKey;
+	}
+	if (options?.interactive === false || process.stdin.isTTY !== true || invocation.noInput || strictIdentity) {
+		if (options?.exitOnFailure === false) return null;
+		const message = authRequiredMessage(context);
+		console.error(invocation.json ? JSON.stringify({
+			success: false,
+			error: {
+				code: "AUTH_REQUIRED",
+				message
+			}
+		}) : chalk.yellow(message));
+		process.exit(1);
+		return null;
+	}
+	console.log(chalk.yellow(`\n${authRequiredMessage(context)}`));
+	if (!await promptConfirm("Would you like to log in now?", { default: true })) {
+		console.log(chalk.gray("Run \"runtype auth login\" when you're ready."));
+		if (options?.exitOnFailure !== false) process.exit(1);
+		return null;
+	}
+	const apiKey = await handleBrowserLogin(context.apiUrl);
+	if (apiKey) {
+		context.apiKey = apiKey;
+		context.credentialSource = "stored";
+	}
+	return apiKey;
+}
+/** Name the organization the invocation needs, so a linked project never reads as "logged out". */
+function authRequiredMessage(context) {
+	if (context.credentialError && context.account) return `The stored login for ${context.account.orgId ?? "your personal account"} could not be read (${context.credentialError}). Log in again with "runtype login" (or set RUNTYPE_CREDENTIAL_STORE=file first if the OS keychain is unavailable here), or set RUNTYPE_API_KEY.`;
+	if (context.requestedOrgId) return `${context.accountSource === "project" && context.projectLink ? `This directory is linked to ${context.requestedOrgId} (${context.projectLink.path})` : `This command targets ${context.requestedOrgId}`}, but there is no stored login for it on ${context.apiUrl}. Run "runtype login" and authorize that organization, or set RUNTYPE_API_KEY.`;
+	return "Authentication required. Run \"runtype auth login\" first or set RUNTYPE_API_KEY.";
+}
+async function handleBrowserLogin(apiUrl) {
+	console.log(chalk.gray("Opening browser for authentication..."));
+	try {
+		const login = await browserLogin({
+			apiUrl,
+			onProgress: (label) => console.log(chalk.gray(label))
+		});
+		const warning = orgMismatchWarning(login);
+		if (warning) {
+			console.log(chalk.yellow(warning));
+			return null;
+		}
+		console.log(chalk.green("Logged in successfully!"));
+		return login.apiKey;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		console.log(chalk.red("Login failed"));
+		console.error(chalk.red(message));
+		return null;
+	}
+}
+export { ensureAuth as n, getAuthenticatedUser as r, authRequiredMessage as t };
+

package/dist/chunk-CQrNhOtv.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { a as printJson } from "./chunk-CcFCyqbB.js";
+import { n as addExecutionInputOptions, r as resolveExecutionInput, t as runExecution } from "./chunk-Cs4pwCQ-.js";
+import { t as buildAgentVersionSelector } from "./chunk-BxNJgYbE.js";
+import { Command } from "commander";
+import chalk from "chalk";
+// src/commands/dispatch.ts
+const dispatchCommand = addExecutionInputOptions(new Command("dispatch").description("Execute a flow or agent via the dispatch API").option("-f, --flow <id>", "Flow ID to execute").option("-a, --agent <id>", "Agent ID to execute").option("--alias <name>", "Run whichever version this release alias points at").option("--version-id <id>", "Run this exact version snapshot").option("-r, --record <id>", "Existing record ID").option("--record-json <file>", "JSON file with record data (use - for stdin)").option("-m, --message <text>", "Message to send").option("--stream", "Stream the response (default)", true).option("--no-stream", "Wait for complete response").option("--json", "Output one final JSON result").option("--jsonl", "Output stream events and a terminal execution_summary as JSON lines").option("--debug", "Show step-level details").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode")).action(async (options) => {
+	await runExecution(options, () => buildDispatchRequest(options), (client, payload) => options.stream ? client.dispatch.executeStream(payload) : client.dispatch.execute(payload), "execution", renderDispatchResult);
+});
+/** Build the canonical dispatch request, validating every input before authentication. */
+function buildDispatchRequest(options) {
+	if (!options.flow && !options.agent) throw new Error("Either --flow or --agent is required");
+	if (options.flow && options.agent) throw new Error("Use only one of --flow and --agent");
+	const selector = buildAgentVersionSelector(options);
+	if (selector && !options.agent) throw new Error("A version selector needs an agent target: pass --agent alongside it.");
+	return {
+		...resolveExecutionInput(options),
+		...options.flow ? { flow: { id: options.flow } } : { agent: {
+			agentId: options.agent,
+			...selector ?? {}
+		} },
+		options: { streamResponse: options.stream }
+	};
+}
+function renderDispatchResult(value) {
+	const result = value;
+	const steps = result.steps;
+	if (!steps) {
+		printJson(result);
+		return;
+	}
+	for (const step of steps) {
+		console.log(chalk.cyan(`\n[${step.name}]`));
+		if (typeof step.result === "string") console.log(step.result);
+		else printJson(step.result);
+	}
+}
+export { dispatchCommand };
+

package/dist/chunk-CW6AzBH6.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+// src/lib/terminal-image.ts
+const ESC = "\x1B";
+const BEL = "\x07";
+const ST = `${ESC}\\`;
+/**
+* Detect whether stdout is an interactive terminal that supports an inline-image
+* protocol we can drive without decoding the image. `env` / `isTTY` are injectable
+* for testing; production callers use the process defaults.
+*/
+function detectImageProtocol(env = process.env, isTTY = process.stdout.isTTY === true) {
+	if (!isTTY) return null;
+	if (env.TERM === "xterm-kitty" || env.KITTY_WINDOW_ID || env.TERM_PROGRAM === "ghostty") return "kitty";
+	if (env.TERM_PROGRAM === "iTerm.app" || env.TERM_PROGRAM === "WezTerm" || env.LC_TERMINAL === "iTerm2") return "iterm2";
+	return null;
+}
+/** Extract `{ mimeType, base64 }` from a `data:<mime>;base64,<data>` URI, or null. */
+function parseImageDataUri(value) {
+	if (typeof value !== "string" || !value.startsWith("data:")) return null;
+	const match = value.match(/^data:([^;,]+)(?:;[^,]*)?;base64,(.+)$/s);
+	if (!match || !match[1] || !match[2]) return null;
+	return {
+		mimeType: match[1],
+		base64: match[2]
+	};
+}
+/** Decoded byte length of a base64 string (no allocation). */
+function base64DecodedByteLength(base64) {
+	const len = base64.length;
+	if (len === 0) return 0;
+	let padding = 0;
+	if (base64.endsWith("==")) padding = 2;
+	else if (base64.endsWith("=")) padding = 1;
+	return Math.floor(len * 3 / 4) - padding;
+}
+/** Split a Kitty payload into `m=`-chunked APC sequences (≤4096 base64 chars each). */
+function kittyImageSequence(base64) {
+	const CHUNK = 4096;
+	if (base64.length <= CHUNK) return `${ESC}_Ga=T,f=100,m=0;${base64}${ST}`;
+	let out = "";
+	for (let i = 0; i < base64.length; i += CHUNK) {
+		const piece = base64.slice(i, i + CHUNK);
+		const more = i + CHUNK < base64.length ? 1 : 0;
+		out += i === 0 ? `${ESC}_Ga=T,f=100,m=${more};${piece}${ST}` : `${ESC}_Gm=${more};${piece}${ST}`;
+	}
+	return out;
+}
+/**
+* Build the escape sequence that renders an inline image for the given protocol,
+* or null when the protocol can't display this format dependency-free (Kitty +
+* non-PNG) so the caller falls back to a text marker.
+*/
+function encodeInlineImage(opts) {
+	const { base64, mimeType, protocol } = opts;
+	if (!base64) return null;
+	if (protocol === "iterm2") {
+		const sizeBytes = base64DecodedByteLength(base64);
+		return `${ESC}]1337;File=inline=1;size=${sizeBytes};width=auto;height=auto;preserveAspectRatio=1:${base64}${BEL}`;
+	}
+	if (mimeType !== "image/png") return null;
+	return kittyImageSequence(base64);
+}
+/**
+* Render an inline image from a `data:` URI for the detected protocol, or null
+* when it isn't a renderable inline-image data URI / format. A convenience that
+* composes {@link parseImageDataUri} + {@link encodeInlineImage}.
+*/
+function renderInlineImage(value, protocol) {
+	const parsed = parseImageDataUri(value);
+	if (!parsed) return null;
+	return encodeInlineImage({
+		base64: parsed.base64,
+		mimeType: parsed.mimeType,
+		protocol
+	});
+}
+// src/lib/message-content.ts
+/**
+* Render a message's `content` to a single human-readable line for the CLI.
+* A plain string passes through; an array of parts renders text inline and collapses media parts to compact markers.
+* This is what keeps read commands from printing `[object Object]` for multi-modal or offloaded messages.
+*/
+function renderMessageContent(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return content == null ? "" : String(content);
+	return content.map((part) => {
+		if (part == null || typeof part !== "object") return part == null ? "" : String(part);
+		const p = part;
+		switch (p.type) {
+			case "text":
+			case "reasoning": return typeof p.text === "string" ? p.text : "";
+			case "image": return `[image${"mimeType" in p && p.mimeType ? ` ${p.mimeType}` : ""}]`;
+			case "file": return `[file${"filename" in p && p.filename ? ` ${p.filename}` : ""}${"mimeType" in p && p.mimeType ? ` (${p.mimeType})` : ""}]`;
+			case "asset_ref": return `[attachment${"filename" in p && p.filename ? ` ${p.filename}` : ""}${"mimeType" in p && p.mimeType ? ` ${p.mimeType}` : ""}]`;
+			default: return typeof p.type === "string" ? `[${p.type}]` : "";
+		}
+	}).filter((s) => s.length > 0).join(" ");
+}
+/**
+* Split a message's `content` into the text line and inline-image escape sequences for renderable parts.
+* Pure; the caller decides how to write (role prefix, ordering).
+* Used only on the interactive image-capable path; unrenderable content degrades to `renderMessageContent`'s marker text.
+*/
+function renderMessageContentWithImages(content, protocol) {
+	if (!Array.isArray(content)) return {
+		text: renderMessageContent(content),
+		images: []
+	};
+	const inline = [];
+	const images = [];
+	for (const part of content) {
+		if (part && typeof part === "object" && part.type === "image") {
+			const image = part.image;
+			const seq = typeof image === "string" ? renderInlineImage(image, protocol) : null;
+			if (seq) {
+				images.push(seq);
+				continue;
+			}
+		}
+		inline.push(renderMessageContent([part]));
+	}
+	return {
+		text: inline.filter((s) => s.length > 0).join(" "),
+		images
+	};
+}
+export { renderMessageContentWithImages as n, detectImageProtocol as r, renderMessageContent as t };
+

package/dist/chunk-CXgL4w-9.js

@@ -0,0 +1,317 @@
+#!/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, i as printDetail, n as buildListParams, s as printNextCursorHint } from "./chunk-CcFCyqbB.js";
+import { c as buildEntityPullCommand, i as SURFACE_ENSURE_SPEC, s as buildEntityEnsureCommand } from "./chunk-BirUxTtH.js";
+import { Command, Option } from "commander";
+import chalk from "chalk";
+import { readFile } from "node:fs/promises";
+// src/commands/surfaces.ts
+const DELIVERY_ID_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
+async function readStdin() {
+	let value = "";
+	process.stdin.setEncoding("utf8");
+	for await (const chunk of process.stdin) value += chunk;
+	return value;
+}
+/** The `--payload` object, read from a file or from stdin when the source is `-`. */
+async function readPayloadObject(source) {
+	const label = source === "-" ? "stdin" : source;
+	const raw = source === "-" ? await readStdin() : await readFile(source, "utf8");
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new Error(`--payload: invalid JSON in ${label}`);
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error(`--payload: ${label} must contain a JSON object`);
+	return parsed;
+}
+/** `Attempt 1: HTTP 202, run exec_1 (route: event_route opened)` */
+function formatDeliveryAttempt(attempt) {
+	const outcome = attempt.deduplicated ? ", deduplicated" : attempt.executionId ? `, run ${attempt.executionId}` : "";
+	const route = attempt.route ? ` (route: ${[attempt.route.matchedBy, attempt.route.pattern].filter(Boolean).join(" ")})` : "";
+	return `Attempt ${attempt.attempt}: HTTP ${attempt.status}${outcome}${route}`;
+}
+function parsePositiveInteger(value, option) {
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed < 1) throw new Error(`${option} must be a positive integer`);
+	return parsed;
+}
+const surfacesCommand = new Command("surfaces").description("View product surfaces");
+surfacesCommand.addCommand(buildEntityEnsureCommand(SURFACE_ENSURE_SPEC));
+surfacesCommand.addCommand(buildEntityPullCommand(SURFACE_ENSURE_SPEC));
+surfacesCommand.command("list").description("List surfaces across your products").option("--json", "Output as JSON").option("--limit <n>", "Maximum number of surfaces to return").option("--cursor <cursor>", "Pagination cursor for the next page").option("--type <type>", "Filter by surface type").option("--status <status>", "Filter by surface status").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 query = buildListParams(options, {
+		type: options.type,
+		status: options.status
+	});
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.get("/surfaces", query);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			const surfaces = data.data ?? [];
+			if (surfaces.length === 0) {
+				console.log("No surfaces found");
+				return;
+			}
+			console.log("Your Surfaces:");
+			for (const surface of surfaces) {
+				console.log(`  ${chalk.green(surface.id)} ${surface.name} [${surface.type}]`);
+				console.log(`    Product: ${surface.productId}`);
+				if (surface.status) console.log(`    Status: ${surface.status}`);
+				if (surface.updatedAt) console.log(`    Updated: ${surface.updatedAt}`);
+			}
+			const total = data.pagination?.totalCount;
+			console.log(chalk.dim(`\n  Showing ${surfaces.length}${total !== void 0 ? ` of ${total}` : ""} surfaces`));
+			printNextCursorHint("runtype surfaces list", data.pagination);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to fetch surfaces: ${message}`));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [items, setItems] = useState(null);
+		const [error, setError] = useState(null);
+		const [total, setTotal] = useState();
+		useEffect(() => {
+			client.get("/surfaces", query).then((res) => {
+				const surfaces = res.data ?? [];
+				setItems(surfaces);
+				setTotal(res.pagination?.totalCount ?? surfaces.length);
+			}).catch((err) => setError(err instanceof Error ? err : new Error(String(err))));
+		}, []);
+		return React.createElement(DataList, {
+			title: "Your Surfaces",
+			items,
+			error,
+			loading: items === null && error === null,
+			total,
+			emptyMessage: "No surfaces found",
+			renderCard: (item) => {
+				const surface = item;
+				return React.createElement(EntityCard, { fields: [
+					{
+						label: "ID",
+						value: surface.id,
+						color: "green"
+					},
+					{
+						label: "Name",
+						value: surface.name
+					},
+					{
+						label: "Type",
+						value: surface.type,
+						color: "gray"
+					},
+					{
+						label: "Product",
+						value: surface.productId,
+						color: "gray"
+					},
+					{
+						label: "Status",
+						value: surface.status,
+						color: "gray"
+					},
+					{
+						label: "Updated",
+						value: surface.updatedAt
+					}
+				] });
+			}
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+surfacesCommand.command("get <id>").description("Get surface details including its items and keys").addOption(new Option("--product <productId>", "Deprecated; surface IDs resolve their product").hideHelp()).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);
+	const detailPath = `/surfaces/${encodeURIComponent(id)}`;
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.get(detailPath);
+			if (options.json) {
+				printJson(data);
+				return;
+			}
+			printDetail("Surface", [
+				{
+					label: "ID",
+					value: data.id
+				},
+				{
+					label: "Name",
+					value: data.name
+				},
+				{
+					label: "Type",
+					value: data.type
+				},
+				{
+					label: "Product",
+					value: data.productId
+				},
+				{
+					label: "Status",
+					value: data.status
+				},
+				{
+					label: "Created",
+					value: data.createdAt
+				},
+				{
+					label: "Updated",
+					value: data.updatedAt
+				}
+			]);
+			const items = data.items ?? [];
+			console.log(chalk.cyan(`\nItems (${items.length}):`));
+			if (items.length === 0) console.log(chalk.gray("  No items"));
+			else for (const item of items) {
+				const label = item.exposedName || item.capabilityName || item.capabilityId;
+				const entry = item.isEntryPoint ? " (entry point)" : "";
+				const enabled = item.enabled === false ? chalk.gray(" [disabled]") : "";
+				console.log(`  ${chalk.green(item.id)} ${label}${entry}${enabled}`);
+			}
+			const keys = data.keys ?? [];
+			console.log(chalk.cyan(`\nKeys (${keys.length}):`));
+			if (keys.length === 0) console.log(chalk.gray("  No keys"));
+			else for (const key of keys) {
+				const prefix = key.keyPrefix ? `${key.keyPrefix}` : "";
+				const status = key.isActive === false ? chalk.gray(" [inactive]") : "";
+				console.log(`  ${chalk.green(key.id)} ${key.name ?? "(unnamed)"} ${prefix}${status}`);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Failed to fetch surface: ${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(detailPath);
+					const items = data.items ?? [];
+					const keys = data.keys ?? [];
+					const itemSummary = items.length === 0 ? "No items" : items.map((i) => `${i.exposedName || i.capabilityName || i.capabilityId}${i.isEntryPoint ? " (entry point)" : ""}`).join("\n");
+					const keySummary = keys.length === 0 ? "No keys" : keys.map((k) => `${k.name ?? "(unnamed)"} ${k.keyPrefix ?? ""}`.trim()).join("\n");
+					setResultNode(React.createElement(EntityCard, { fields: [
+						{
+							label: "ID",
+							value: data.id,
+							color: "green"
+						},
+						{
+							label: "Name",
+							value: data.name
+						},
+						{
+							label: "Type",
+							value: data.type,
+							color: "gray"
+						},
+						{
+							label: "Product",
+							value: data.productId,
+							color: "gray"
+						},
+						{
+							label: "Status",
+							value: data.status,
+							color: "gray"
+						},
+						{
+							label: "Created",
+							value: data.createdAt
+						},
+						{
+							label: "Updated",
+							value: data.updatedAt
+						},
+						{
+							label: `Items (${items.length})`,
+							value: itemSummary
+						},
+						{
+							label: `Keys (${keys.length})`,
+							value: keySummary
+						}
+					] }));
+					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 surface...",
+			success,
+			successMessage: "Surface",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+surfacesCommand.command("test <id>").description("Send a provider fixture through a surface’s real ingress").addOption(new Option("--product <productId>", "Deprecated; surface IDs resolve their product").hideHelp()).requiredOption("--fixture <fixture>", "Fixture name, such as github.pull_request.opened or github.pull_request.merged_plan").requiredOption("--repo <owner/repository>", "GitHub repository in owner/repository format").requiredOption("--pr <number>", "Pull request number").option("--repeat <number>", "Deliver the same provider event more than once", "1").option("--planning-path <path>", "Planning-document directory for merged-plan fixtures").option("--delivery-id <id>", "Reuse a previous delivery ID (X-GitHub-Delivery), to check the surface handles a repeat once").option("--payload <file>", "Send and sign this JSON object instead of the built fixture; - reads it from stdin").option("--json", "Output as JSON").action(async (id, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	try {
+		const pullRequest = parsePositiveInteger(options.pr, "--pr");
+		const repeat = parsePositiveInteger(options.repeat, "--repeat");
+		if (repeat > 3) throw new Error("--repeat must not exceed 3");
+		if (options.deliveryId !== void 0 && !DELIVERY_ID_PATTERN.test(options.deliveryId)) throw new Error("--delivery-id must be 1-128 letters, digits, dots, underscores, colons or hyphens");
+		const payload = options.payload !== void 0 ? await readPayloadObject(options.payload) : void 0;
+		const result = await createCliClient(apiKey).post(`/surfaces/${encodeURIComponent(id)}/test-deliveries`, {
+			fixture: options.fixture,
+			repository: options.repo,
+			pullRequest,
+			repeat,
+			...options.planningPath ? { planningPath: options.planningPath } : {},
+			...options.deliveryId ? { deliveryId: options.deliveryId } : {},
+			...payload ? { payload } : {}
+		});
+		if (options.json) {
+			printJson(result);
+			return;
+		}
+		console.log(chalk.green("Test delivery accepted"));
+		console.log(`  Surface:  ${result.surface.id} [${result.surface.type}/${result.surface.provider}]`);
+		console.log(`  Fixture:  ${result.fixture}`);
+		console.log(`  Source:   ${result.repository}#${result.pullRequest}`);
+		console.log(`  Delivery: ${result.deliveryId}`);
+		for (const attempt of result.attempts) console.log(`  ${formatDeliveryAttempt(attempt)}`);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		console.error(chalk.red(`Failed to test surface: ${message}`));
+		process.exitCode = 1;
+	}
+});
+export { surfacesCommand };
+