@prisma/cli 3.0.0-alpha.7 → 3.0.0-alpha.9

package/dist/controllers/app.js

@@ -8,13 +8,14 @@ import { confirmPrompt, selectPrompt, textPrompt } from "../shell/prompt.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
 import { readAuthState } from "../lib/auth/auth-ops.js";
 import { parseEnvAssignments } from "../lib/app/env-vars.js";
+import { renderDeployOutputRows } from "../lib/app/deploy-output.js";
 import { readBunPackageJson } from "../lib/app/bun-project.js";
 import { DEFAULT_LOCAL_DEV_PORT, resolveLocalBuildType, runLocalApp } from "../lib/app/local-dev.js";
 import { inferTargetName, projectNotFoundError, resolveProjectTarget } from "../lib/project/resolution.js";
 import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, ensureLocalResolutionPinGitignore, readLocalResolutionPin, writeLocalResolutionPin } from "../lib/project/local-pin.js";
 import { PREVIEW_BUILD_TYPES, RESOLVED_PREVIEW_BUILD_TYPES, executePreviewBuild } from "../lib/app/preview-build.js";
 import { PREVIEW_DEFAULT_REGION } from "../lib/app/preview-interaction.js";
-import { createPreviewDeployProgress, createPreviewPromoteProgress, createPreviewUpdateEnvProgress } from "../lib/app/preview-progress.js";
+import { createPreviewDeployProgress, createPreviewDeployProgressState, createPreviewPromoteProgress, createPreviewUpdateEnvProgress } from "../lib/app/preview-progress.js";
 import { createPreviewAppProvider } from "../lib/app/preview-provider.js";
 import { createSelectPromptPort } from "./select-prompt-port.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
@@ -123,7 +124,6 @@ async function runAppDeploy(context, appName, options) {
 	});
 	await maybeRenderDeploySetupBlock(context, {
 		firstDeploy: selectedApp.firstDeploy,
-		showSubsequentAnnotations: skipLocalPin,
 		workspaceName: target.workspace.name,
 		projectName: target.project.name,
 		projectAnnotation: annotationForProjectResolution(target.resolution),
@@ -147,6 +147,17 @@ async function runAppDeploy(context, appName, options) {
 	const buildType = framework.buildType;
 	assertSupportedEntrypoint(buildType, options?.entrypoint, "deploy");
 	const portMapping = parseDeployPortMapping(String(runtime.port));
+	const shouldWriteLocalPin = firstDeploy && !skipLocalPin;
+	if (shouldWriteLocalPin) {
+		await writeLocalResolutionPin(context.runtime.cwd, {
+			workspaceId: target.workspace.id,
+			projectId: target.project.id
+		});
+		await ensureLocalResolutionPinGitignore(context.runtime.cwd);
+		maybeRenderLocalPinBound(context, target.project.name);
+	}
+	const progressState = createPreviewDeployProgressState();
+	const deployStartedAt = Date.now();
 	const deployResult = await provider.deployApp({
 		cwd: context.runtime.cwd,
 		projectId,
@@ -159,23 +170,16 @@ async function runAppDeploy(context, appName, options) {
 		portMapping,
 		envVars,
 		interaction: void 0,
-		progress: createPreviewDeployProgress(context.output.stderr, !context.flags.json && !context.flags.quiet)
+		progress: createPreviewDeployProgress(context.output.stderr, context.ui, !context.flags.json && !context.flags.quiet, progressState)
 	}).catch((error) => {
-		throw deployFailedError("App deploy failed", error, ["prisma-cli app list-deploys"]);
+		throw appDeployFailedError(error, progressState);
 	});
+	const deployDurationMs = Date.now() - deployStartedAt;
 	await context.stateStore.setSelectedApp(projectId, {
 		id: deployResult.app.id,
 		name: deployResult.app.name
 	});
 	await context.stateStore.setKnownLiveDeployment(projectId, deployResult.app.id, deployResult.deployment.id);
-	const shouldWriteLocalPin = firstDeploy && !skipLocalPin;
-	if (shouldWriteLocalPin) {
-		await writeLocalResolutionPin(context.runtime.cwd, {
-			workspaceId: target.workspace.id,
-			projectId: target.project.id
-		});
-		await ensureLocalResolutionPinGitignore(context.runtime.cwd);
-	}
 	return {
 		command: "app.deploy",
 		result: {
@@ -188,6 +192,7 @@ async function runAppDeploy(context, appName, options) {
 				name: deployResult.app.name
 			},
 			deployment: deployResult.deployment,
+			durationMs: deployDurationMs,
 			localPin: shouldWriteLocalPin ? {
 				path: LOCAL_RESOLUTION_PIN_RELATIVE_PATH,
 				written: true
@@ -1054,9 +1059,10 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 			}
 		}, branch);
 	}
-	if (options.localPin.kind === "present") {
-		if (options.localPin.pin.workspaceId !== workspace.id) throw localResolutionPinStaleError();
-		const project = projects.find((candidate) => candidate.id === options.localPin.pin.projectId);
+	const localPin = options.localPin;
+	if (localPin.kind === "present") {
+		if (localPin.pin.workspaceId !== workspace.id) throw localResolutionPinStaleError();
+		const project = projects.find((candidate) => candidate.id === localPin.pin.projectId);
 		if (!project) throw localResolutionPinStaleError();
 		return withDeployBranch({
 			workspace,
@@ -1257,7 +1263,12 @@ function frameworkNotDetectedError(cwd, requestedFramework) {
 }
 async function maybeRenderDeploySetupBlock(context, details) {
 	if (context.flags.json || context.flags.quiet) return;
-	const title = `${details.firstDeploy ? "Set up" : "Deploying"} ${formatDeployDirectory(context.runtime.cwd)}`;
+	const directory = formatDeployDirectory(context.runtime.cwd);
+	if (!details.firstDeploy) {
+		context.output.stderr.write(`Deploying ${directory} to ${details.projectName} / ${details.branchName} / ${details.appName}\n\n`);
+		return;
+	}
+	const title = `Setting up your local directory ${formatLocalDirectory(context.runtime.cwd, context.runtime.env)}`;
 	const rows = details.firstDeploy ? [
 		{
 			label: "Workspace",
@@ -1266,61 +1277,41 @@ async function maybeRenderDeploySetupBlock(context, details) {
 		{
 			label: "Project",
 			value: details.projectName,
-			annotation: details.projectAnnotation
+			origin: details.projectAnnotation
 		},
 		{
 			label: "Branch",
 			value: details.branchName,
-			annotation: details.branchAnnotation
+			origin: details.branchAnnotation
 		},
 		{
 			label: "App",
 			value: details.appName,
-			annotation: details.appAnnotation
+			origin: details.appAnnotation
 		},
 		{
 			label: "Framework",
 			value: details.framework.displayName,
-			annotation: details.framework.annotation
+			origin: details.framework.annotation
 		},
 		{
 			label: "Runtime",
 			value: `HTTP ${details.runtime.port}`,
-			annotation: details.runtime.annotation
+			origin: details.runtime.annotation
 		}
-	] : [
-		{
-			label: "Workspace",
-			value: details.workspaceName
-		},
-		{
-			label: "Project",
-			value: details.projectName,
-			annotation: details.showSubsequentAnnotations ? details.projectAnnotation : void 0
-		},
-		{
-			label: "Branch",
-			value: details.branchName,
-			annotation: details.showSubsequentAnnotations ? details.branchAnnotation : void 0
-		},
-		{
-			label: "App",
-			value: details.appName,
-			annotation: details.showSubsequentAnnotations ? details.appAnnotation : void 0
-		}
-	];
-	const lines = details.firstDeploy ? [
+	] : [];
+	const lines = [
 		title,
 		"",
-		...renderDeploySetupRows(context, rows),
-		""
-	] : [
-		title,
-		...renderDeploySetupRows(context, rows),
+		...renderDeployOutputRows(context.ui, rows),
 		""
 	];
 	context.output.stderr.write(`${lines.join("\n")}\n`);
 }
+function maybeRenderLocalPinBound(context, projectName) {
+	if (context.flags.json || context.flags.quiet) return;
+	context.output.stderr.write(`This directory is now linked to project ${projectName}.\n\n`);
+}
 async function maybeCustomizeDeploySettings(context, options) {
 	if (!options.firstDeploy || context.flags.yes || options.explicitFramework || options.explicitBuildType || options.explicitHttpPort || !canPrompt(context)) return {
 		framework: options.framework,
@@ -1364,19 +1355,16 @@ async function maybeCustomizeDeploySettings(context, options) {
 		value: `HTTP ${runtime.port}`,
 		annotation: runtime.annotation
 	} : null].filter((row) => Boolean(row));
-	if (changedRows.length > 0 && !context.flags.quiet && !context.flags.json) context.output.stderr.write(`${renderDeploySetupRows(context, changedRows).join("\n")}\n\n`);
+	if (changedRows.length > 0 && !context.flags.quiet && !context.flags.json) context.output.stderr.write(`${renderDeployOutputRows(context.ui, changedRows.map((row) => ({
+		label: row.label,
+		value: row.value,
+		origin: row.annotation
+	}))).join("\n")}\n\n`);
 	return {
 		framework,
 		runtime
 	};
 }
-function renderDeploySetupRows(context, rows) {
-	const labelWidth = Math.max(...rows.map((row) => row.label.length));
-	const valueWidth = Math.max(...rows.map((row) => row.value.length));
-	return rows.map((row) => {
-		return `  ${row.label.padEnd(labelWidth)}  ${row.value.padEnd(valueWidth)}${row.annotation ? `  ${context.ui.dim(row.annotation)}` : ""}`.trimEnd();
-	});
-}
 function annotationForProjectResolution(resolution) {
 	switch (resolution.projectSource) {
 		case "explicit": return "set by --project";
@@ -1410,6 +1398,15 @@ function formatDeployDirectory(cwd) {
 	const basename = path.basename(cwd);
 	return basename ? `./${basename}` : ".";
 }
+function formatLocalDirectory(cwd, env) {
+	const resolved = path.resolve(cwd);
+	const home = env.HOME ? path.resolve(env.HOME) : null;
+	if (home && (resolved === home || resolved.startsWith(`${home}${path.sep}`))) {
+		const relative = path.relative(home, resolved);
+		return relative ? `~/${relative}` : "~";
+	}
+	return resolved;
+}
 async function readCurrentWorkspaceId(context) {
 	const state = await context.stateStore.read();
 	if (state.auth?.workspaceId) return state.auth.workspaceId;
@@ -1467,6 +1464,67 @@ function deployFailedError(summary, error, nextSteps) {
 		nextSteps
 	});
 }
+function appDeployFailedError(error, progress) {
+	const why = error instanceof Error ? error.message : String(error);
+	const debug = formatDebugDetails(error);
+	if (progress.buildStarted && !progress.buildCompleted) return new CliError({
+		code: "BUILD_FAILED",
+		domain: "app",
+		summary: "Build failed locally.",
+		why,
+		fix: "Inspect the build output above, fix the error, and redeploy.",
+		debug,
+		meta: { phase: "build" },
+		humanLines: [
+			"Build failed locally.",
+			"",
+			`✗ Built       ${why}`,
+			"",
+			"Fix: Inspect the build output above, fix the error, and redeploy."
+		],
+		exitCode: 1,
+		nextSteps: []
+	});
+	if (!progress.buildStarted) return deployFailedError("App deploy failed", error, ["prisma-cli app deploy"]);
+	const phaseHeadline = progress.containerLive ? "The deployment started, but the app is not ready yet." : "Deploy failed after the build completed.";
+	const recoveryLines = progress.versionId ? ["See what happened", `prisma-cli app logs --deployment ${progress.versionId}`] : ["Fix", "Retry the command, or rerun with --trace for more detailed diagnostics."];
+	const urlLines = progress.deploymentUrl ? [
+		"",
+		"URL",
+		progress.deploymentUrl
+	] : [];
+	const humanLines = progress.containerLive ? [
+		phaseHeadline,
+		"",
+		"This is usually a missing env var, a failed DB connection,",
+		"or a crash on startup.",
+		"",
+		...recoveryLines,
+		...urlLines
+	] : [
+		phaseHeadline,
+		"",
+		progress.uploadCompleted ? "The artifact uploaded, but the deployment did not start." : progress.archiveReady ? "The app built locally, but the artifact did not finish uploading." : "The app built locally, but the deployment did not start.",
+		"",
+		...recoveryLines
+	];
+	return new CliError({
+		code: "DEPLOY_FAILED",
+		domain: "app",
+		summary: phaseHeadline,
+		why,
+		fix: progress.versionId ? `Inspect logs with prisma-cli app logs --deployment ${progress.versionId}.` : "Retry the command, or rerun with --trace for more detailed diagnostics.",
+		debug,
+		meta: {
+			phase: progress.containerLive ? "runtime_ready" : "deploy",
+			deploymentId: progress.versionId,
+			deploymentUrl: progress.deploymentUrl
+		},
+		humanLines,
+		exitCode: 1,
+		nextSteps: []
+	});
+}
 function localResolutionPinStaleError() {
 	return new CliError({
 		code: "LOCAL_STATE_STALE",

package/dist/lib/app/deploy-output.js

@@ -0,0 +1,15 @@
+import { padDisplay } from "../../shell/ui.js";
+//#region src/lib/app/deploy-output.ts
+const DEPLOY_OUTPUT_MIN_LABEL_WIDTH = 9;
+const DEPLOY_OUTPUT_MIN_VALUE_WIDTH = 9;
+function renderDeployOutputRows(ui, rows) {
+	if (rows.length === 0) return [];
+	const labelWidth = Math.max(DEPLOY_OUTPUT_MIN_LABEL_WIDTH, ...rows.map((row) => row.label.length));
+	const valueWidth = Math.max(DEPLOY_OUTPUT_MIN_VALUE_WIDTH, ...rows.map((row) => row.value?.length ?? 0));
+	return rows.map((row) => {
+		if (!row.value) return `  ${row.label}`;
+		return `  ${padDisplay(row.label, labelWidth)}  ${padDisplay(ui.strong(row.value), valueWidth)}${row.origin ? `  ${ui.dim(`· ${row.origin}`)}` : ""}`.trimEnd();
+	});
+}
+//#endregion
+export { renderDeployOutputRows };

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

@@ -1,5 +1,5 @@
 import { resolveBunEntrypoint } from "./bun-project.js";
-import { cp, readdir, readlink, rm, stat } from "node:fs/promises";
+import { chmod, copyFile, cp, lstat, mkdir, readFile, readdir, readlink, rm, stat } from "node:fs/promises";
 import path from "node:path";
 import { AstroBuild, BunBuild, NextjsBuild, NuxtBuild, TanstackStartBuild } from "@prisma/compute-sdk";
 //#region src/lib/app/preview-build.ts
@@ -46,6 +46,7 @@ async function executePreviewBuild(options) {
 	});
 	const artifact = await strategy.execute();
 	try {
+		if (buildType === "nextjs") await restageNextjsArtifact(artifact.directory, options.appPath);
 		await normalizeArtifactSymlinks(artifact.directory, options.appPath);
 		return {
 			artifact,
@@ -104,6 +105,38 @@ async function createPreviewBuildStrategy(options) {
 		}
 	}
 }
+async function stageNextjsStandaloneArtifact(options) {
+	const standaloneRoot = path.resolve(options.standaloneDir);
+	const artifactRoot = path.resolve(options.artifactDir);
+	const appRoot = path.resolve(options.appPath);
+	await copyPathMaterializingSymlinks(standaloneRoot, artifactRoot, {
+		standaloneRoot,
+		appRoot,
+		sourceRoot: await resolveSourceRoot(appRoot)
+	});
+}
+async function restageNextjsArtifact(artifactDir, appPath) {
+	const standaloneDir = path.join(appPath, ".next", "standalone");
+	await rm(artifactDir, {
+		recursive: true,
+		force: true
+	});
+	await stageNextjsStandaloneArtifact({
+		standaloneDir,
+		artifactDir,
+		appPath
+	});
+	const publicDir = path.join(appPath, "public");
+	if (await directoryExists(publicDir)) await cp(publicDir, path.join(artifactDir, "public"), {
+		recursive: true,
+		verbatimSymlinks: true
+	});
+	const staticDir = path.join(appPath, ".next", "static");
+	if (await directoryExists(staticDir)) await cp(staticDir, path.join(artifactDir, ".next", "static"), {
+		recursive: true,
+		verbatimSymlinks: true
+	});
+}
 async function normalizeArtifactSymlinks(artifactDir, appPath) {
 	const normalizedArtifactDir = path.resolve(artifactDir);
 	const normalizedAppPath = path.resolve(appPath);
@@ -138,5 +171,69 @@ function isPathWithin(rootPath, candidatePath) {
 	const relativePath = path.relative(rootPath, candidatePath);
 	return relativePath === "" || !relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath);
 }
+async function copyPathMaterializingSymlinks(sourcePath, destinationPath, options) {
+	const sourceStat = await lstat(sourcePath);
+	if (sourceStat.isSymbolicLink()) {
+		await copyPathMaterializingSymlinks(await resolveSymlinkTarget(sourcePath, options), destinationPath, options);
+		return;
+	}
+	if (sourceStat.isDirectory()) {
+		await mkdir(destinationPath, { recursive: true });
+		const entries = await readdir(sourcePath, { withFileTypes: true });
+		for (const entry of entries) await copyPathMaterializingSymlinks(path.join(sourcePath, entry.name), path.join(destinationPath, entry.name), options);
+		return;
+	}
+	if (sourceStat.isFile()) {
+		await mkdir(path.dirname(destinationPath), { recursive: true });
+		await copyFile(sourcePath, destinationPath);
+		await chmod(destinationPath, sourceStat.mode);
+	}
+}
+async function resolveSymlinkTarget(symlinkPath, options) {
+	const linkTarget = await readlink(symlinkPath);
+	const resolvedTarget = path.resolve(path.dirname(symlinkPath), linkTarget);
+	if (await pathExists(resolvedTarget)) {
+		if (!isPathWithin(options.appRoot, resolvedTarget) && !isPathWithin(options.sourceRoot, resolvedTarget)) throw new Error(`Build artifact symlink escapes the app directory: ${resolvedTarget}`);
+		return resolvedTarget;
+	}
+	if (isPathWithin(options.standaloneRoot, resolvedTarget)) {
+		const fallbackTarget = path.join(options.appRoot, path.relative(options.standaloneRoot, resolvedTarget));
+		if (await pathExists(fallbackTarget)) return fallbackTarget;
+	}
+	throw new Error(`Next.js standalone symlink target is missing: ${symlinkPath} -> ${linkTarget} (resolved to ${resolvedTarget})`);
+}
+async function pathExists(targetPath) {
+	try {
+		await stat(targetPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function directoryExists(targetPath) {
+	try {
+		return (await stat(targetPath)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+async function resolveSourceRoot(appRoot) {
+	let current = path.resolve(appRoot);
+	while (true) {
+		if (await pathExists(path.join(current, ".git")) || await pathExists(path.join(current, "pnpm-workspace.yaml")) || await pathExists(path.join(current, "bun.lock")) || await pathExists(path.join(current, "bun.lockb")) || await packageJsonDeclaresWorkspaces(current)) return current;
+		const parent = path.dirname(current);
+		if (parent === current) return path.resolve(appRoot);
+		current = parent;
+	}
+}
+async function packageJsonDeclaresWorkspaces(directory) {
+	try {
+		const content = await readFile(path.join(directory, "package.json"), "utf8");
+		const parsed = JSON.parse(content);
+		return Boolean(parsed.workspaces);
+	} catch {
+		return false;
+	}
+}
 //#endregion
 export { PREVIEW_BUILD_TYPES, PreviewBuildStrategy, RESOLVED_PREVIEW_BUILD_TYPES, executePreviewBuild };

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

@@ -1,83 +1,68 @@
+import { renderDeployOutputRows } from "./deploy-output.js";
 //#region src/lib/app/preview-progress.ts
-function createPreviewDeployProgress(output, enabled) {
-	if (!enabled) return;
+function createPreviewDeployProgressState() {
+	return {
+		buildStarted: false,
+		buildCompleted: false,
+		archiveReady: false,
+		uploadCompleted: false,
+		versionId: null,
+		startRequested: false,
+		containerLive: false,
+		deploymentUrl: null,
+		promotedUrl: null
+	};
+}
+function createPreviewDeployProgress(output, ui, enabled, state = createPreviewDeployProgressState()) {
 	const write = (line) => {
+		if (!enabled) return;
 		output.write(`${line}\n`);
 	};
+	const writeRows = (rows) => {
+		for (const line of renderDeployOutputRows(ui, rows)) write(line);
+	};
 	return {
 		onBuildStart() {
-			write("Building application...");
+			state.buildStarted = true;
+			write("Building locally...");
 		},
 		onBuildComplete() {
-			write("Build complete.");
-		},
-		onArchiveCreating() {
-			write("Creating deployment artifact...");
+			state.buildCompleted = true;
 		},
 		onArchiveReady(byteLength) {
-			write(`Artifact ready (${(byteLength / 1024).toFixed(1)} KB).`);
+			state.archiveReady = true;
+			writeRows([{
+				label: "Built",
+				value: formatArtifactSize(byteLength)
+			}]);
+		},
+		onUploadStart() {
+			write("Uploading...");
 		},
 		onVersionCreated(versionId) {
-			write(`Deployment ${versionId} created.`);
+			state.versionId = versionId;
 		},
 		onUploadComplete() {
-			write("Upload complete.");
+			state.uploadCompleted = true;
+			writeRows([{ label: "Uploaded" }]);
 		},
 		onStartRequested() {
-			write("Starting deployment...");
-		},
-		onStatusChange(status) {
-			write(`Status: ${status}`);
+			state.startRequested = true;
+			write("Deploying...");
 		},
 		onRunning(url) {
-			if (url) {
-				write(`Deployment is running at ${url}.`);
-				return;
-			}
-			write("Deployment is running.");
-		},
-		onPromoteStart() {
-			write("Promoting deployment...");
+			state.containerLive = true;
+			state.deploymentUrl = url;
+			writeRows([{ label: "Deployed" }]);
 		},
 		onPromoted(url) {
-			if (url) {
-				write(`Promoted to ${url}.`);
-				return;
-			}
-			write("Promotion complete.");
-		},
-		onPromoteFailed(error) {
-			write(`Promotion failed${error?.message ? `: ${error.message}` : "."}`);
-		},
-		onOldVersionStopping(versionId) {
-			write(`Stopping previous deployment ${versionId}...`);
-		},
-		onOldVersionStopped(versionId) {
-			write(`Previous deployment ${versionId} stopped.`);
-		},
-		onOldVersionStopFailed(versionId) {
-			write(`Failed to stop previous deployment ${versionId} (non-fatal).`);
-		},
-		onOldVersionDeleting(versionId) {
-			write(`Deleting previous deployment ${versionId}...`);
-		},
-		onOldVersionDeleted(versionId) {
-			write(`Previous deployment ${versionId} deleted.`);
-		},
-		onOldVersionDeleteFailed(versionId) {
-			write(`Failed to delete previous deployment ${versionId} (non-fatal).`);
-		},
-		onCleanupDanglingVersion(versionId) {
-			write(`Cleaning up deployment ${versionId}...`);
-		},
-		onCleanupDanglingVersionComplete(versionId) {
-			write(`Deployment ${versionId} cleaned up.`);
-		},
-		onCleanupDanglingVersionFailed(versionId) {
-			write(`Failed to clean up deployment ${versionId}.`);
+			state.promotedUrl = url;
 		}
 	};
 }
+function formatArtifactSize(byteLength) {
+	return `${(byteLength / 1024 / 1024).toFixed(1)} MB`;
+}
 function createPreviewPromoteProgress(output, enabled) {
 	if (!enabled) return;
 	const write = (line) => {
@@ -136,4 +121,4 @@ function createPreviewUpdateEnvProgress(output, enabled) {
 	};
 }
 //#endregion
-export { createPreviewDeployProgress, createPreviewPromoteProgress, createPreviewUpdateEnvProgress };
+export { createPreviewDeployProgress, createPreviewDeployProgressState, createPreviewPromoteProgress, createPreviewUpdateEnvProgress };

package/dist/presenters/app.js

@@ -1,3 +1,4 @@
+import { renderDeployOutputRows } from "../lib/app/deploy-output.js";
 import { renderList, renderShow, serializeList } from "../output/patterns.js";
 //#region src/presenters/app.ts
 function renderAppBuild(context, descriptor, result) {
@@ -25,49 +26,24 @@ function serializeAppBuild(result) {
 	return result;
 }
 function renderAppDeploy(context, descriptor, result) {
-	const lines = renderShow({
-		title: "Deploying the selected app.",
-		descriptor,
-		fields: [
-			{
-				key: "workspace",
-				value: result.workspace.name
-			},
-			{
-				key: "project",
-				value: result.project.name
-			},
-			{
-				key: "branch",
-				value: result.branch.name
-			},
-			{
-				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"
-			}] : []
-		]
-	}, context.ui);
-	if (result.localPin?.written) lines.push(`Bound this directory in ${result.localPin.path}. Subsequent commands target the same Project.`);
-	return lines;
+	return [
+		`Live in ${formatDuration(result.durationMs)}`,
+		...result.deployment.url ? [context.ui.link(result.deployment.url)] : [],
+		"",
+		...renderDeployOutputRows(context.ui, [{
+			label: "Logs",
+			value: "prisma-cli app logs"
+		}])
+	];
 }
 function serializeAppDeploy(result) {
 	const { localPin: _localPin, ...serialized } = result;
 	return serialized;
 }
+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.",

package/dist/shell/errors.js

@@ -12,6 +12,7 @@ var CliError = class extends Error {
 	docsUrl;
 	exitCode;
 	nextSteps;
+	humanLines;
 	constructor(options) {
 		super(options.summary);
 		this.name = "CliError";
@@ -27,6 +28,7 @@ var CliError = class extends Error {
 		this.docsUrl = options.docsUrl ?? null;
 		this.exitCode = options.exitCode ?? 1;
 		this.nextSteps = options.nextSteps ?? [];
+		this.humanLines = options.humanLines && options.humanLines.length > 0 ? [...options.humanLines] : null;
 	}
 };
 function usageError(summary, why, fix, nextSteps = [], domain = "cli") {

package/dist/shell/output.js

@@ -36,6 +36,17 @@ function writeHumanLines(output, lines) {
 	output.stderr.write(`${lines.join("\n")}\n`);
 }
 function writeHumanError(output, ui, error, options) {
+	if (error.humanLines && error.humanLines.length > 0) {
+		const lines = [...error.humanLines];
+		if (options.trace && error.debug) {
+			lines.push("");
+			lines.push("Trace:");
+			lines.push(...error.debug.trimEnd().split("\n"));
+		}
+		lines.push(...renderNextSteps(error.nextSteps));
+		writeHumanLines(output, lines);
+		return;
+	}
 	const lines = [renderSummaryLine(ui, "error", `${error.summary} [${error.code}]`)];
 	if (error.where) lines.push(...["", `Where: ${error.where}`]);
 	if (error.why) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-alpha.7",
+  "version": "3.0.0-alpha.9",
   "description": "Preview of the unified Prisma CLI.",
   "type": "module",
   "bin": {