@prisma/cli 3.0.0-alpha.9 → 3.0.0-beta.0

package/dist/lib/app/env-config.js

@@ -3,10 +3,11 @@ import { usageError } from "../../shell/errors.js";
 const VALID_ROLES = new Set(["production", "preview"]);
 function positionalHint(command) {
 	if (command === "add" || command === "update") return "KEY=value ";
-	if (command === "rm") return "KEY ";
+	if (command === "remove") return "KEY ";
 	return "";
 }
 function resolveEnvScope(flags, options) {
+	if (flags.roleName && flags.branchName) throw usageError(`prisma-cli project env ${options.command} accepts either --role or --branch`, "--role targets a project-level config map; --branch targets a preview branch override.", "Pass exactly one scope flag.", [`prisma-cli project env ${options.command} ${positionalHint(options.command)}--role preview`, `prisma-cli project env ${options.command} ${positionalHint(options.command)}--branch feature/foo`], "app");
 	if (flags.roleName) {
 		if (!VALID_ROLES.has(flags.roleName)) throw usageError(`Unknown role "${flags.roleName}"`, "--role accepts production or preview.", "Pass --role production or --role preview.", [`prisma-cli project env ${options.command} --role production`, `prisma-cli project env ${options.command} --role preview`], "app");
 		return {
@@ -14,9 +15,17 @@ function resolveEnvScope(flags, options) {
 			role: flags.roleName
 		};
 	}
+	if (flags.branchName) return {
+		kind: "branch",
+		branchName: flags.branchName
+	};
 	if (options.requireExplicit) {
 		const positional = positionalHint(options.command);
-		throw usageError(`prisma-cli project env ${options.command} requires --role`, "Writing without an explicit scope is rejected so the command never silently targets production.", "Pass --role production or --role preview.", [`prisma-cli project env ${options.command} ${positional}--role production`, `prisma-cli project env ${options.command} ${positional}--role preview`], "app");
+		throw usageError(`prisma-cli project env ${options.command} requires --role or --branch`, "Writing without an explicit scope is rejected so the command never silently targets production.", "Pass --role production, --role preview, or --branch <git-name>.", [
+			`prisma-cli project env ${options.command} ${positional}--role production`,
+			`prisma-cli project env ${options.command} ${positional}--role preview`,
+			`prisma-cli project env ${options.command} ${positional}--branch feature/foo`
+		], "app");
 	}
 	return null;
 }
@@ -38,7 +47,7 @@ function parseKeyValuePositional(raw, command, env = process.env) {
 	const key = raw.slice(0, separatorIndex);
 	const value = raw.slice(separatorIndex + 1);
 	validateKey(key, command);
-	if (value.length === 0) throw usageError(`KEY=VALUE argument has an empty value`, `"${raw}" has an empty value after the = separator.`, `Pass a non-empty value, or use prisma-cli project env rm to remove a variable.`, [`prisma-cli project env ${command} ${key}=value --role production`], "app");
+	if (value.length === 0) throw usageError(`KEY=VALUE argument has an empty value`, `"${raw}" has an empty value after the = separator.`, `Pass a non-empty value, or use prisma-cli project env remove to remove a variable.`, [`prisma-cli project env ${command} ${key}=value --role production`], "app");
 	return {
 		key,
 		value
@@ -46,12 +55,13 @@ function parseKeyValuePositional(raw, command, env = process.env) {
 }
 const KEY_SHAPE = /^[A-Z_][A-Z0-9_]*$/;
 function validateKey(key, command) {
-	if (key.length === 0) throw usageError(`Variable key cannot be empty`, "An empty key was passed.", "Pass an env-var key, e.g. STRIPE_KEY.", [`prisma-cli project env ${command} STRIPE_KEY${command === "rm" ? "" : "=value"} --role production`], "app");
+	if (key.length === 0) throw usageError(`Variable key cannot be empty`, "An empty key was passed.", "Pass an env-var key, e.g. STRIPE_KEY.", [`prisma-cli project env ${command} STRIPE_KEY${command === "remove" ? "" : "=value"} --role production`], "app");
 	if (key.length > 256) throw usageError(`Variable key "${key}" exceeds the 256-character limit`, "Env-var keys are capped at 256 characters by the platform.", "Use a shorter key.", [], "app");
-	if (!KEY_SHAPE.test(key)) throw usageError(`Variable key "${key}" must match the POSIX env-var shape`, "Keys must start with an uppercase letter or underscore and contain only uppercase letters, digits, and underscores.", "Rename the key to match [A-Z_][A-Z0-9_]*.", [`prisma-cli project env ${command} STRIPE_KEY${command === "rm" ? "" : "=value"} --role production`], "app");
+	if (!KEY_SHAPE.test(key)) throw usageError(`Variable key "${key}" must match the POSIX env-var shape`, "Keys must start with an uppercase letter or underscore and contain only uppercase letters, digits, and underscores.", "Rename the key to match [A-Z_][A-Z0-9_]*.", [`prisma-cli project env ${command} STRIPE_KEY${command === "remove" ? "" : "=value"} --role production`], "app");
 }
 function formatScopeLabel(scope) {
-	return scope.role;
+	if (scope.kind === "role") return scope.role;
+	return `branch:${scope.branchName}`;
 }
 //#endregion
 export { formatScopeLabel, parseKeyValuePositional, resolveEnvScope };

package/dist/lib/app/preview-build.js

@@ -46,7 +46,7 @@ async function executePreviewBuild(options) {
 	});
 	const artifact = await strategy.execute();
 	try {
-		if (buildType === "nextjs") await restageNextjsArtifact(artifact.directory, options.appPath);
+		if (buildType === "nextjs") await restageNextjsArtifact(artifact, options.appPath);
 		await normalizeArtifactSymlinks(artifact.directory, options.appPath);
 		return {
 			artifact,
@@ -114,8 +114,10 @@ async function stageNextjsStandaloneArtifact(options) {
 		appRoot,
 		sourceRoot: await resolveSourceRoot(appRoot)
 	});
+	await hoistPnpmDependencies(path.join(artifactRoot, "node_modules"));
 }
-async function restageNextjsArtifact(artifactDir, appPath) {
+async function restageNextjsArtifact(artifact, appPath) {
+	const artifactDir = artifact.directory;
 	const standaloneDir = path.join(appPath, ".next", "standalone");
 	await rm(artifactDir, {
 		recursive: true,
@@ -126,17 +128,52 @@ async function restageNextjsArtifact(artifactDir, appPath) {
 		artifactDir,
 		appPath
 	});
+	const serverSubpath = nextjsServerSubpath(artifact.entrypoint);
+	const serverDir = serverSubpath ? path.join(artifactDir, serverSubpath) : artifactDir;
 	const publicDir = path.join(appPath, "public");
-	if (await directoryExists(publicDir)) await cp(publicDir, path.join(artifactDir, "public"), {
+	if (await directoryExists(publicDir)) await cp(publicDir, path.join(serverDir, "public"), {
 		recursive: true,
 		verbatimSymlinks: true
 	});
 	const staticDir = path.join(appPath, ".next", "static");
-	if (await directoryExists(staticDir)) await cp(staticDir, path.join(artifactDir, ".next", "static"), {
+	if (await directoryExists(staticDir)) await cp(staticDir, path.join(serverDir, ".next", "static"), {
 		recursive: true,
 		verbatimSymlinks: true
 	});
 }
+function nextjsServerSubpath(entrypoint) {
+	const dir = path.posix.dirname(entrypoint);
+	return dir === "." ? "" : dir;
+}
+async function hoistPnpmDependencies(nodeModulesDir) {
+	const pnpmNodeModulesDir = path.join(nodeModulesDir, ".pnpm", "node_modules");
+	if (!await directoryExists(pnpmNodeModulesDir)) return;
+	const entries = await readdir(pnpmNodeModulesDir, { withFileTypes: true });
+	for (const entry of entries) {
+		const sourcePath = path.join(pnpmNodeModulesDir, entry.name);
+		if (entry.name.startsWith("@") && entry.isDirectory()) {
+			const scopedEntries = await readdir(sourcePath, { withFileTypes: true });
+			for (const scopedEntry of scopedEntries) {
+				const scopedDestination = path.join(nodeModulesDir, entry.name, scopedEntry.name);
+				if (await pathExists(scopedDestination)) continue;
+				await mkdir(path.dirname(scopedDestination), { recursive: true });
+				await copyPathMaterializingSymlinks(path.join(sourcePath, scopedEntry.name), scopedDestination, {
+					standaloneRoot: pnpmNodeModulesDir,
+					appRoot: nodeModulesDir,
+					sourceRoot: nodeModulesDir
+				});
+			}
+			continue;
+		}
+		const destinationPath = path.join(nodeModulesDir, entry.name);
+		if (await pathExists(destinationPath)) continue;
+		await copyPathMaterializingSymlinks(sourcePath, destinationPath, {
+			standaloneRoot: pnpmNodeModulesDir,
+			appRoot: nodeModulesDir,
+			sourceRoot: nodeModulesDir
+		});
+	}
+}
 async function normalizeArtifactSymlinks(artifactDir, appPath) {
 	const normalizedArtifactDir = path.resolve(artifactDir);
 	const normalizedAppPath = path.resolve(appPath);
@@ -174,7 +211,9 @@ function isPathWithin(rootPath, candidatePath) {
 async function copyPathMaterializingSymlinks(sourcePath, destinationPath, options) {
 	const sourceStat = await lstat(sourcePath);
 	if (sourceStat.isSymbolicLink()) {
-		await copyPathMaterializingSymlinks(await resolveSymlinkTarget(sourcePath, options), destinationPath, options);
+		const resolvedTarget = await resolveSymlinkTarget(sourcePath, options);
+		if (resolvedTarget === null) return;
+		await copyPathMaterializingSymlinks(resolvedTarget, destinationPath, options);
 		return;
 	}
 	if (sourceStat.isDirectory()) {
@@ -200,8 +239,14 @@ async function resolveSymlinkTarget(symlinkPath, options) {
 		const fallbackTarget = path.join(options.appRoot, path.relative(options.standaloneRoot, resolvedTarget));
 		if (await pathExists(fallbackTarget)) return fallbackTarget;
 	}
+	if (isPnpmHoistLink(symlinkPath)) return null;
 	throw new Error(`Next.js standalone symlink target is missing: ${symlinkPath} -> ${linkTarget} (resolved to ${resolvedTarget})`);
 }
+function isPnpmHoistLink(symlinkPath) {
+	const parts = path.dirname(symlinkPath).split(path.sep);
+	for (let i = 0; i < parts.length - 1; i++) if (parts[i] === ".pnpm" && parts[i + 1] === "node_modules") return true;
+	return false;
+}
 async function pathExists(targetPath) {
 	try {
 		await stat(targetPath);

package/dist/lib/app/preview-progress.js

@@ -96,29 +96,5 @@ function createPreviewPromoteProgress(output, enabled) {
 		}
 	};
 }
-function createPreviewUpdateEnvProgress(output, enabled) {
-	if (!enabled) return;
-	const write = (line) => {
-		output.write(`${line}\n`);
-	};
-	return {
-		onVersionCreated(versionId) {
-			write(`Creating updated deployment ${versionId}...`);
-		},
-		onStartRequested() {
-			write("Starting deployment...");
-		},
-		onStatusChange(status) {
-			write(`Status: ${status}`);
-		},
-		onRunning(url) {
-			if (url) {
-				write(`Deployment is running at ${url}.`);
-				return;
-			}
-			write("Deployment is running.");
-		}
-	};
-}
 //#endregion
-export { createPreviewDeployProgress, createPreviewDeployProgressState, createPreviewPromoteProgress, createPreviewUpdateEnvProgress };
+export { createPreviewDeployProgress, createPreviewDeployProgressState, createPreviewPromoteProgress };

package/dist/lib/app/preview-provider.js

@@ -3,6 +3,18 @@ import { PreviewBuildStrategy } from "./preview-build.js";
 import path from "node:path";
 import { ApiError, CancelledError, ComputeClient, streamLogs } from "@prisma/compute-sdk";
 //#region src/lib/app/preview-provider.ts
+var PreviewDomainApiError = class extends Error {
+	status;
+	code;
+	hint;
+	constructor(options) {
+		super(`${options.summary}: ${options.message}${options.hint ? ` ${options.hint}` : ""}`);
+		this.name = "PreviewDomainApiError";
+		this.status = options.status;
+		this.code = options.code ?? null;
+		this.hint = options.hint ?? null;
+	}
+};
 function createPreviewAppProvider(client, options) {
 	const sdk = new ComputeClient(client);
 	return {
@@ -35,6 +47,43 @@ function createPreviewAppProvider(client, options) {
 				name: appResult.value.name
 			};
 		},
+		async listDomains(appId) {
+			return listComputeServiceDomains(client, appId);
+		},
+		async addDomain(options) {
+			const result = await client.POST("/v1/compute-services/{computeServiceId}/domains", {
+				params: { path: { computeServiceId: options.appId } },
+				body: { hostname: options.hostname }
+			});
+			if (result.error || !result.data) {
+				if (result.response.status === 409) {
+					const existing = (await listComputeServiceDomains(client, options.appId)).find((domain) => sameHostname(domain.hostname, options.hostname));
+					if (existing) return {
+						domain: existing,
+						existing: true
+					};
+				}
+				throw domainApiCallError("Failed to add custom domain", result.response, result.error);
+			}
+			return {
+				domain: normalizeDomainRecord(result.data.data),
+				existing: false
+			};
+		},
+		async showDomain(domainId) {
+			const result = await client.GET("/v1/domains/{domainId}", { params: { path: { domainId } } });
+			if (result.error || !result.data) throw domainApiCallError("Failed to show custom domain", result.response, result.error);
+			return normalizeDomainRecord(result.data.data);
+		},
+		async removeDomain(domainId) {
+			const result = await client.DELETE("/v1/domains/{domainId}", { params: { path: { domainId } } });
+			if (result.error) throw domainApiCallError("Failed to remove custom domain", result.response, result.error);
+		},
+		async retryDomain(domainId) {
+			const result = await client.POST("/v1/domains/{domainId}/retry", { params: { path: { domainId } } });
+			if (result.error || !result.data) throw domainApiCallError("Failed to retry custom domain", result.response, result.error);
+			return normalizeDomainRecord(result.data.data);
+		},
 		async promoteDeployment(options) {
 			const promoteResult = await sdk.promote({
 				serviceId: options.appId,
@@ -263,6 +312,46 @@ async function listComputeServices(client, options) {
 		liveUrl: toAbsoluteUrl(service.serviceEndpointDomain ?? null)
 	}));
 }
+async function listComputeServiceDomains(client, computeServiceId) {
+	const result = await client.GET("/v1/compute-services/{computeServiceId}/domains", { params: { path: { computeServiceId } } });
+	if (result.error || !result.data) throw domainApiCallError("Failed to list custom domains", result.response, result.error);
+	return result.data.data.map((domain) => normalizeDomainRecord(domain));
+}
+function normalizeDomainRecord(domain) {
+	return {
+		id: domain.id,
+		type: domain.type,
+		url: domain.url,
+		hostname: domain.hostname,
+		computeServiceId: domain.computeServiceId,
+		status: domain.status,
+		foundryStatus: domain.foundryStatus,
+		failureReason: domain.failureReason,
+		failureCategory: domain.failureCategory,
+		certExpiresAt: domain.certExpiresAt,
+		createdAt: domain.createdAt,
+		updatedAt: domain.updatedAt,
+		dnsRecords: normalizeDomainDnsRecords(domain.dnsRecords)
+	};
+}
+function normalizeDomainDnsRecords(records) {
+	if (!Array.isArray(records)) return [];
+	return records.map((record) => {
+		if (typeof record.type !== "string" || typeof record.name !== "string" || typeof record.value !== "string") return null;
+		return {
+			type: record.type,
+			name: record.name,
+			value: record.value,
+			ttl: typeof record.ttl === "number" ? record.ttl : null
+		};
+	}).filter((record) => Boolean(record));
+}
+function sameHostname(left, right) {
+	return normalizeHostnameForComparison(left) === normalizeHostnameForComparison(right);
+}
+function normalizeHostnameForComparison(hostname) {
+	return hostname.trim().replace(/\.$/, "").toLowerCase();
+}
 async function createBranchApp(client, options) {
 	const branch = await resolveOrCreateBranch(client, {
 		projectId: options.projectId,
@@ -301,6 +390,15 @@ function apiCallError(summary, response, error) {
 	const hint = error.error?.hint ? ` ${error.error.hint}` : "";
 	return /* @__PURE__ */ new Error(`${summary}: ${message}${hint}`);
 }
+function domainApiCallError(summary, response, error) {
+	return new PreviewDomainApiError({
+		summary,
+		status: response.status,
+		code: error.error?.code ?? null,
+		message: error.error?.message ?? `Management API returned HTTP ${response.status}.`,
+		hint: error.error?.hint ?? null
+	});
+}
 async function findAppForDeployment(sdk, deploymentId) {
 	const projectsResult = await sdk.listProjects();
 	if (projectsResult.isErr()) throw new Error(projectsResult.error.message);
@@ -330,4 +428,4 @@ function toAbsoluteUrl(url) {
 	return url.startsWith("https://") || url.startsWith("http://") ? url : `https://${url}`;
 }
 //#endregion
-export { createPreviewAppProvider };
+export { PreviewDomainApiError, createPreviewAppProvider };

package/dist/presenters/app-env.js

@@ -1,7 +1,8 @@
 import { renderList, renderShow, serializeList } from "../output/patterns.js";
 //#region src/presenters/app-env.ts
 function scopeLabel(scope) {
-	return scope.role;
+	if (scope.kind === "role") return scope.role ?? "unknown";
+	return `branch:${scope.branchName ?? scope.branchId ?? "unknown"}`;
 }
 function renderEnvAdd(context, descriptor, result) {
 	return renderShow({
@@ -79,7 +80,7 @@ function renderEnvList(context, descriptor, result) {
 		},
 		items: result.variables.map((variable) => ({
 			noun: "variable",
-			label: variable.key,
+			label: `${variable.key} (${variable.source})`,
 			id: variable.id,
 			status: variable.isManagedBySystem ? "default" : null
 		})),
@@ -94,7 +95,7 @@ function serializeEnvList(result) {
 			context: { scope: scopeLabel(result.scope) },
 			items: result.variables.map((variable) => ({
 				noun: "variable",
-				label: variable.key,
+				label: `${variable.key} (${variable.source})`,
 				id: variable.id,
 				status: variable.isManagedBySystem ? "default" : null
 			}))

package/dist/presenters/app.js

@@ -1,4 +1,5 @@
 import { renderDeployOutputRows } from "../lib/app/deploy-output.js";
+import { formatDomainFailureFix } from "../lib/app/domain-guidance.js";
 import { renderList, renderShow, serializeList } from "../output/patterns.js";
 //#region src/presenters/app.ts
 function renderAppBuild(context, descriptor, result) {
@@ -44,74 +45,6 @@ function formatDuration(durationMs) {
 	if (durationMs < 1e3) return `${durationMs}ms`;
 	return `${(durationMs / 1e3).toFixed(1)}s`;
 }
-function renderAppUpdateEnv(context, descriptor, result) {
-	return renderShow({
-		title: "Updating environment variables for the selected app.",
-		descriptor,
-		fields: [
-			{
-				key: "project",
-				value: result.projectId
-			},
-			{
-				key: "app",
-				value: result.app.name
-			},
-			{
-				key: "deployment",
-				value: result.deployment.id
-			},
-			{
-				key: "status",
-				value: result.deployment.status,
-				tone: toneForStatus(result.deployment.status)
-			},
-			...result.deployment.url ? [{
-				key: "url",
-				value: result.deployment.url,
-				tone: "link"
-			}] : [],
-			{
-				key: "variables",
-				value: formatVariableNames(result.variables),
-				tone: result.variables.length > 0 ? "default" : "dim"
-			}
-		]
-	}, context.ui);
-}
-function serializeAppUpdateEnv(result) {
-	return result;
-}
-function renderAppListEnv(context, descriptor, result) {
-	return renderShow({
-		title: "Listing environment variables for the selected app.",
-		descriptor,
-		fields: [
-			{
-				key: "project",
-				value: result.projectId
-			},
-			{
-				key: "app",
-				value: result.app?.name ?? "not selected",
-				tone: result.app ? "default" : "dim"
-			},
-			{
-				key: "deployment",
-				value: result.deployment?.id ?? "none",
-				tone: result.deployment ? toneForStatus(result.deployment.status) : "dim"
-			},
-			{
-				key: "variables",
-				value: formatVariableNames(result.variables),
-				tone: result.variables.length > 0 ? "default" : "dim"
-			}
-		]
-	}, context.ui);
-}
-function serializeAppListEnv(result) {
-	return result;
-}
 function renderAppListDeploys(context, descriptor, result) {
 	return renderList({
 		title: "Listing deployments for the selected app.",
@@ -253,6 +186,105 @@ function renderAppOpen(context, descriptor, result) {
 function serializeAppOpen(result) {
 	return result;
 }
+function renderAppDomainAdd(context, descriptor, result) {
+	return renderShow({
+		title: result.existing ? "Showing the existing custom domain for the selected app." : "Adding a custom domain to the selected app.",
+		descriptor,
+		fields: [
+			...domainTargetFields(result),
+			{
+				key: "hostname",
+				value: result.domain.hostname
+			},
+			{
+				key: "status",
+				value: result.domain.status,
+				tone: toneForDomainStatus(result.domain.status)
+			},
+			...domainDnsFields(result.domain)
+		]
+	}, context.ui);
+}
+function serializeAppDomainAdd(result) {
+	return result;
+}
+function renderAppDomainShow(context, descriptor, result) {
+	return renderShow({
+		title: "Showing custom domain status.",
+		descriptor,
+		fields: [
+			...domainTargetFields(result),
+			{
+				key: "hostname",
+				value: result.domain.hostname
+			},
+			{
+				key: "status",
+				value: result.domain.status,
+				tone: toneForDomainStatus(result.domain.status)
+			},
+			...domainFailureFields(result.domain),
+			{
+				key: "cert expires",
+				value: formatOptionalUtcDate(result.domain.certExpiresAt),
+				tone: result.domain.certExpiresAt ? "default" : "dim"
+			},
+			{
+				key: "created",
+				value: formatUtcDate(result.domain.createdAt),
+				tone: "dim"
+			},
+			...domainDnsFields(result.domain)
+		]
+	}, context.ui);
+}
+function serializeAppDomainShow(result) {
+	return result;
+}
+function renderAppDomainRemove(context, descriptor, result) {
+	return renderShow({
+		title: "Removing a custom domain from the selected app.",
+		descriptor,
+		fields: [
+			...domainTargetFields(result),
+			{
+				key: "hostname",
+				value: result.hostname
+			},
+			{
+				key: "removed",
+				value: result.removed ? "yes" : "no",
+				tone: result.removed ? "success" : "dim"
+			}
+		]
+	}, context.ui);
+}
+function serializeAppDomainRemove(result) {
+	return result;
+}
+function renderAppDomainRetry(context, descriptor, result) {
+	return renderShow({
+		title: "Retrying custom domain verification.",
+		descriptor,
+		fields: [
+			...domainTargetFields(result),
+			{
+				key: "hostname",
+				value: result.domain.hostname
+			},
+			{
+				key: "status",
+				value: result.domain.status,
+				tone: toneForDomainStatus(result.domain.status)
+			},
+			...domainFailureFields(result.domain),
+			...domainDnsFields(result.domain)
+		]
+	}, context.ui);
+}
+function serializeAppDomainRetry(result) {
+	return result;
+}
 function renderAppPromote(context, descriptor, result) {
 	return renderShow({
 		title: "Switching the live deployment for the selected app.",
@@ -380,13 +412,80 @@ function toneForStatus(status) {
 	if (status === "failed" || status === "error") return "error";
 	return "default";
 }
+function toneForDomainStatus(status) {
+	if (status === "active") return "success";
+	if (status === "failed") return "error";
+	if (status === "pending_dns" || status === "verifying" || status === "provisioning_tls" || status === "verified_routing_blocked") return "warning";
+	return "default";
+}
+function domainTargetFields(result) {
+	return [
+		{
+			key: "workspace",
+			value: result.workspace.name
+		},
+		{
+			key: "project",
+			value: result.project.name
+		},
+		{
+			key: "branch",
+			value: result.branch.name
+		},
+		{
+			key: "app",
+			value: result.app.name
+		}
+	];
+}
+function domainDnsFields(domain) {
+	const records = domain.dnsRecords;
+	if (records.length === 0) return [{
+		key: "dns record",
+		value: "not provided by platform",
+		tone: "dim"
+	}];
+	return [{
+		key: "dns record",
+		value: records.map((record) => {
+			const ttl = record.ttl ? ` ttl ${record.ttl}` : "";
+			return `${record.type} ${record.name} -> ${record.value}${ttl}`;
+		}).join(", ")
+	}];
+}
+function formatDomainFailure(domain) {
+	if (!domain.failureReason) return domain.failureCategory ?? "none";
+	return domain.failureCategory ? `${domain.failureCategory} - ${domain.failureReason}` : domain.failureReason;
+}
+function domainFailureFields(domain) {
+	const tone = hasDomainFailure(domain) ? "error" : "dim";
+	return [{
+		key: "failure",
+		value: formatDomainFailure(domain),
+		tone
+	}, ...domainFixFields(domain)];
+}
+function hasDomainFailure(domain) {
+	return Boolean(domain.failureCategory || domain.failureReason);
+}
+function domainFixFields(domain) {
+	const fix = formatDomainFailureFix(domain);
+	return fix ? [{
+		key: "fix",
+		value: fix
+	}] : [];
+}
+function formatOptionalUtcDate(value) {
+	return value ? formatUtcDate(value) : "-";
+}
+function formatUtcDate(value) {
+	const date = new Date(value);
+	if (Number.isNaN(date.getTime())) return value;
+	return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}-${String(date.getUTCDate()).padStart(2, "0")} ${String(date.getUTCHours()).padStart(2, "0")}:${String(date.getUTCMinutes()).padStart(2, "0")} UTC`;
+}
 function formatRecentDeployments(deployments) {
 	if (deployments.length === 0) return "none";
 	return deployments.map((deployment) => `${deployment.id}${deployment.live ? " (live)" : ""}`).join(", ");
 }
-function formatVariableNames(variables) {
-	if (variables.length === 0) return "none";
-	return variables.join(", ");
-}
 //#endregion
-export { renderAppBuild, renderAppDeploy, renderAppListDeploys, renderAppListEnv, renderAppOpen, renderAppPromote, renderAppRemove, renderAppRollback, renderAppRun, renderAppShow, renderAppShowDeploy, renderAppUpdateEnv, serializeAppBuild, serializeAppDeploy, serializeAppListDeploys, serializeAppListEnv, serializeAppOpen, serializeAppPromote, serializeAppRemove, serializeAppRollback, serializeAppRun, serializeAppShow, serializeAppShowDeploy, serializeAppUpdateEnv };
+export { renderAppBuild, renderAppDeploy, renderAppDomainAdd, renderAppDomainRemove, renderAppDomainRetry, renderAppDomainShow, renderAppListDeploys, renderAppOpen, renderAppPromote, renderAppRemove, renderAppRollback, renderAppRun, renderAppShow, renderAppShowDeploy, serializeAppBuild, serializeAppDeploy, serializeAppDomainAdd, serializeAppDomainRemove, serializeAppDomainRetry, serializeAppDomainShow, serializeAppListDeploys, serializeAppOpen, serializeAppPromote, serializeAppRemove, serializeAppRollback, serializeAppRun, serializeAppShow, serializeAppShowDeploy };