@prisma/cli 3.0.0-alpha.6 → 3.0.0-alpha.8

package/dist/lib/app/bun-project.js

@@ -1,5 +1,5 @@
-import path from "node:path";
 import { access, readFile } from "node:fs/promises";
+import path from "node:path";
 //#region src/lib/app/bun-project.ts
 async function readBunPackageJson(appPath) {
 	const packageJsonPath = path.join(appPath, "package.json");

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/local-dev.js

@@ -1,6 +1,6 @@
 import { readBunPackageEntrypoint, readBunPackageJson, resolveBunEntrypoint } from "./bun-project.js";
-import path from "node:path";
 import { access } from "node:fs/promises";
+import path from "node:path";
 import { spawn } from "node:child_process";
 //#region src/lib/app/local-dev.ts
 const NEXT_CONFIG_FILENAMES = [

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

@@ -1,6 +1,6 @@
 import { resolveBunEntrypoint } from "./bun-project.js";
-import path from "node:path";
 import { cp, 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
 const PREVIEW_BUILD_TYPES = [

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

@@ -1,38 +1,5 @@
-import { selectPrompt, textPrompt } from "../../shell/prompt.js";
+import "../../shell/prompt.js";
 //#region src/lib/app/preview-interaction.ts
-const CREATE_NEW_APP = "__create_new_app__";
 const PREVIEW_DEFAULT_REGION = "eu-central-1";
-function createPreviewDeployInteraction(context) {
-	return {
-		async selectService(services) {
-			const sorted = services.slice().sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
-			const selection = await selectPrompt({
-				input: context.runtime.stdin,
-				output: context.runtime.stderr,
-				message: "Select an app",
-				choices: [...sorted.map((service) => ({
-					label: service.name,
-					value: service.id
-				})), {
-					label: "Create a new app",
-					value: CREATE_NEW_APP
-				}]
-			});
-			return selection === CREATE_NEW_APP ? null : selection;
-		},
-		async provideServiceName() {
-			return textPrompt({
-				input: context.runtime.stdin,
-				output: context.runtime.stderr,
-				message: "App name",
-				placeholder: "hello-world",
-				validate: (value) => !value?.trim() ? "App name is required" : void 0
-			}).then((value) => value.trim());
-		},
-		async selectRegion(_regions) {
-			return PREVIEW_DEFAULT_REGION;
-		}
-	};
-}
 //#endregion
-export { PREVIEW_DEFAULT_REGION, createPreviewDeployInteraction };
+export { PREVIEW_DEFAULT_REGION };

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/lib/app/preview-provider.js

@@ -14,25 +14,11 @@ function createPreviewAppProvider(client, options) {
 				name: projectResult.value.name
 			};
 		},
-		async listApps(projectId) {
-			const servicesResult = await sdk.listServices({ projectId });
-			if (servicesResult.isErr()) throw new Error(servicesResult.error.message);
-			return (await Promise.all(servicesResult.value.map(async (service) => {
-				const detailResult = await sdk.showService({ serviceId: service.id });
-				return detailResult.isOk() ? detailResult.value : {
-					id: service.id,
-					name: service.name,
-					region: service.region,
-					latestVersionId: null,
-					serviceEndpointDomain: void 0
-				};
-			}))).map((service) => ({
-				id: service.id,
-				name: service.name,
-				region: service.region ?? null,
-				liveDeploymentId: service.latestVersionId ?? null,
-				liveUrl: toAbsoluteUrl(service.serviceEndpointDomain ?? null)
-			}));
+		async listApps(projectId, options) {
+			return listComputeServices(client, {
+				projectId,
+				branchGitName: options?.branchName
+			});
 		},
 		async removeApp(appId) {
 			const appResult = await sdk.showService({ serviceId: appId });
@@ -60,6 +46,20 @@ function createPreviewAppProvider(client, options) {
 			if (promoteResult.isErr()) throw new Error(promoteResult.error.message);
 		},
 		async deployApp(options) {
+			const resolvedApp = options.appId ? {
+				appId: options.appId,
+				appName: options.appName,
+				region: options.region
+			} : options.branchName && options.appName ? await createBranchApp(client, {
+				projectId: options.projectId,
+				branchName: options.branchName,
+				appName: options.appName,
+				region: options.region
+			}) : {
+				appId: void 0,
+				appName: options.appName,
+				region: options.region
+			};
 			const deployResult = await sdk.deploy({
 				strategy: new PreviewBuildStrategy({
 					appPath: path.resolve(options.cwd),
@@ -67,9 +67,9 @@ function createPreviewAppProvider(client, options) {
 					buildType: options.buildType
 				}),
 				projectId: options.projectId,
-				serviceId: options.appId,
-				serviceName: options.appName,
-				region: options.region,
+				serviceId: resolvedApp.appId,
+				serviceName: resolvedApp.appName,
+				region: resolvedApp.region,
 				portMapping: options.portMapping,
 				envVars: options.envVars,
 				timeoutSeconds: 120,
@@ -213,6 +213,94 @@ function createPreviewAppProvider(client, options) {
 		}
 	};
 }
+async function listBranches(client, options) {
+	const result = await client.GET("/v1/projects/{projectId}/branches", { params: {
+		path: { projectId: options.projectId },
+		query: { gitName: options.gitName }
+	} });
+	if (result.error || !result.data) throw apiCallError("Failed to list branches", result.response, result.error);
+	return result.data.data;
+}
+async function resolveOrCreateBranch(client, options) {
+	const existing = (await listBranches(client, options))[0];
+	if (existing) return existing;
+	const result = await client.POST("/v1/projects/{projectId}/branches", {
+		params: { path: { projectId: options.projectId } },
+		body: {
+			gitName: options.gitName,
+			isDefault: options.gitName === "main"
+		}
+	});
+	if (result.error || !result.data) {
+		if (result.response.status === 409) {
+			const raced = (await listBranches(client, options))[0];
+			if (raced) return raced;
+		}
+		throw apiCallError(`Failed to create branch "${options.gitName}"`, result.response, result.error);
+	}
+	return result.data.data;
+}
+async function listComputeServices(client, options) {
+	const services = [];
+	let cursor;
+	while (true) {
+		const result = await client.GET("/v1/compute-services", { params: { query: {
+			projectId: options.projectId,
+			branchGitName: options.branchGitName,
+			cursor
+		} } });
+		if (result.error || !result.data) throw apiCallError("Failed to list apps", result.response, result.error);
+		services.push(...result.data.data);
+		if (!result.data.pagination.hasMore || !result.data.pagination.nextCursor) break;
+		cursor = result.data.pagination.nextCursor;
+	}
+	return services.map((service) => ({
+		id: service.id,
+		name: service.name,
+		region: service.region.id ?? null,
+		branchId: service.branchId,
+		liveDeploymentId: service.latestVersionId ?? null,
+		liveUrl: toAbsoluteUrl(service.serviceEndpointDomain ?? null)
+	}));
+}
+async function createBranchApp(client, options) {
+	const branch = await resolveOrCreateBranch(client, {
+		projectId: options.projectId,
+		gitName: options.branchName
+	});
+	const result = await client.POST("/v1/compute-services", { body: {
+		projectId: options.projectId,
+		branchId: branch.id,
+		displayName: options.appName,
+		...options.region ? { regionId: options.region } : {}
+	} });
+	if (result.error || !result.data) {
+		if (result.response.status === 409) {
+			const matched = (await listComputeServices(client, {
+				projectId: options.projectId,
+				branchGitName: options.branchName
+			})).find((app) => app.name === options.appName);
+			if (matched) return {
+				appId: matched.id,
+				appName: matched.name,
+				region: matched.region ?? options.region
+			};
+		}
+		throw apiCallError(`Failed to create app "${options.appName}"`, result.response, result.error);
+	}
+	const service = result.data.data;
+	return {
+		appId: service.id,
+		appName: service.name,
+		region: service.region.id ?? options.region
+	};
+}
+function apiCallError(summary, response, error) {
+	if (response.status === 404) return /* @__PURE__ */ new Error("Resource Not Found");
+	const message = error.error?.message ?? `Management API returned HTTP ${response.status}.`;
+	const hint = error.error?.hint ? ` ${error.error.hint}` : "";
+	return /* @__PURE__ */ new Error(`${summary}: ${message}${hint}`);
+}
 async function findAppForDeployment(sdk, deploymentId) {
 	const projectsResult = await sdk.listProjects();
 	if (projectsResult.isErr()) throw new Error(projectsResult.error.message);

package/dist/lib/auth/client.js

@@ -1,5 +1,5 @@
-import os from "node:os";
 import path from "node:path";
+import os from "node:os";
 //#region src/lib/auth/client.ts
 const CLIENT_ID = "cmm3lndn701oo0uefvxzo0ivw";
 const SERVICE_TOKEN_ENV_VAR = "PRISMA_SERVICE_TOKEN";

package/dist/lib/project/local-pin.js

@@ -0,0 +1,51 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+//#region src/lib/project/local-pin.ts
+const LOCAL_RESOLUTION_PIN_RELATIVE_PATH = ".prisma/local.json";
+async function readLocalResolutionPin(cwd) {
+	try {
+		const raw = await readFile(path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH), "utf8");
+		const parsed = JSON.parse(raw);
+		if (!isLocalResolutionPin(parsed)) return { kind: "invalid" };
+		return {
+			kind: "present",
+			pin: parsed
+		};
+	} catch (error) {
+		if (error.code === "ENOENT") return { kind: "missing" };
+		if (error instanceof SyntaxError) return { kind: "invalid" };
+		throw error;
+	}
+}
+async function writeLocalResolutionPin(cwd, pin) {
+	const prismaDir = path.join(cwd, ".prisma");
+	await mkdir(prismaDir, { recursive: true });
+	const pinPath = path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH);
+	const tmpPath = path.join(prismaDir, `local.${process.pid}.${Date.now()}.tmp`);
+	await writeFile(tmpPath, `${JSON.stringify(pin, null, 2)}\n`, "utf8");
+	await rename(tmpPath, pinPath);
+}
+async function ensureLocalResolutionPinGitignore(cwd) {
+	const gitignorePath = path.join(cwd, ".gitignore");
+	let existing = null;
+	try {
+		existing = await readFile(gitignorePath, "utf8");
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	if (existing === null) {
+		await writeFile(gitignorePath, ".prisma/\n", "utf8");
+		return;
+	}
+	if (existing.split(/\r?\n/).map((line) => line.trim()).some((line) => line === ".prisma/" || line === ".prisma/local.json")) return;
+	await writeFile(gitignorePath, existing.endsWith("\n") ? `${existing}.prisma/\n` : `${existing}\n.prisma/\n`, "utf8");
+}
+function isLocalResolutionPin(value) {
+	if (!value || typeof value !== "object") return false;
+	const keys = Object.keys(value);
+	if (keys.length !== 2 || !keys.includes("workspaceId") || !keys.includes("projectId")) return false;
+	const candidate = value;
+	return typeof candidate.workspaceId === "string" && candidate.workspaceId.trim().length > 0 && typeof candidate.projectId === "string" && candidate.projectId.trim().length > 0;
+}
+//#endregion
+export { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, ensureLocalResolutionPinGitignore, readLocalResolutionPin, writeLocalResolutionPin };

package/dist/lib/project/resolution.js

@@ -1,33 +1,44 @@
 import { CliError } from "../../shell/errors.js";
 import { canPrompt } from "../../shell/runtime.js";
-import path from "node:path";
 import { readFile } from "node:fs/promises";
+import path from "node:path";
 //#region src/lib/project/resolution.ts
 async function resolveProjectTarget(options) {
 	const projects = await options.listProjects();
-	if (options.explicitProject) return rememberIfRequested(options, resolveExplicitProject(options.explicitProject, projects, options.workspace), "explicit");
+	const inferredName = await inferTargetName(options.context.runtime.cwd);
+	if (options.explicitProject) return rememberIfRequested(options, resolveExplicitProject(options.explicitProject, projects, options.workspace), "explicit", {
+		targetName: options.explicitProject,
+		targetNameSource: "explicit"
+	});
 	const platformMapping = await resolveDurablePlatformMapping();
 	if (platformMapping) return rememberIfRequested(options, platformMapping, "platform-mapping");
-	const remembered = await options.context.stateStore.readRememberedProject(options.workspace.id);
 	let staleRemembered = false;
-	if (remembered) {
-		const matched = projects.find((project) => project.id === remembered.id);
-		if (matched) return rememberIfRequested(options, matched, "remembered-local");
-		staleRemembered = true;
+	if (!options.allowCreate) {
+		const rememberedResult = await resolveRememberedProject(options, projects);
+		if (rememberedResult.target) return rememberedResult.target;
+		staleRemembered = rememberedResult.stale;
 	}
-	const packageName = await readPackageName(options.context.runtime.cwd);
+	const packageName = inferredName.source === "package-name" ? inferredName.name : null;
 	if (packageName) {
 		const matches = projects.filter((project) => projectMatchesPackageName(project, packageName));
-		if (matches.length === 1) return rememberIfRequested(options, matches[0], "package-name");
-		if (matches.length > 1) return resolveAmbiguousProject(options, matches, "package-name");
+		if (matches.length === 1) return rememberIfRequested(options, matches[0], "package-name", {
+			targetName: packageName,
+			targetNameSource: "package-name"
+		});
+		if (matches.length > 1) return resolveAmbiguousProject(options, matches, packageName, "package-name");
 	}
 	if (options.allowCreate && options.createProject) {
-		const inferredName = packageName ?? path.basename(options.context.runtime.cwd);
-		if (inferredName) {
-			const existing = projects.filter((project) => projectMatchesPackageName(project, inferredName));
-			if (existing.length === 1) return rememberIfRequested(options, existing[0], "package-name");
-			if (existing.length > 1) return resolveAmbiguousProject(options, existing, "package-name");
-			return rememberIfRequested(options, await options.createProject(inferredName), "created");
+		if (inferredName.name) {
+			const existing = projects.filter((project) => projectMatchesPackageName(project, inferredName.name));
+			if (existing.length === 1) return rememberIfRequested(options, existing[0], inferredName.source, {
+				targetName: inferredName.name,
+				targetNameSource: inferredName.source
+			});
+			if (existing.length > 1) return resolveAmbiguousProject(options, existing, inferredName.name, inferredName.source);
+			return rememberIfRequested(options, await options.createProject(inferredName.name), "created", {
+				targetName: inferredName.name,
+				targetNameSource: inferredName.source
+			});
 		}
 	}
 	if (options.prompt && canPrompt(options.context) && projects.length > 0) return rememberIfRequested(options, await options.prompt.select({
@@ -40,6 +51,25 @@ async function resolveProjectTarget(options) {
 	if (staleRemembered && projects.length > 1) throw localStateStaleError();
 	throw projectUnresolvedError();
 }
+async function resolveRememberedProject(options, projects) {
+	const remembered = await options.context.stateStore.readRememberedProject(options.workspace.id);
+	if (!remembered) return {
+		target: null,
+		stale: false
+	};
+	const matched = projects.find((project) => project.id === remembered.id);
+	if (!matched) return {
+		target: null,
+		stale: true
+	};
+	return {
+		target: await rememberIfRequested(options, matched, "remembered-local", {
+			targetName: remembered.name,
+			targetNameSource: "remembered-local"
+		}),
+		stale: false
+	};
+}
 function projectNotFoundError(projectRef, workspace) {
 	return new CliError({
 		code: "PROJECT_NOT_FOUND",
@@ -104,6 +134,20 @@ async function readPackageName(cwd) {
 		throw error;
 	}
 }
+async function inferTargetName(cwd) {
+	const packageName = await readPackageName(cwd);
+	if (packageName && isValidInferredTargetName(packageName)) return {
+		name: packageName,
+		source: "package-name"
+	};
+	return {
+		name: path.basename(cwd),
+		source: "directory-name"
+	};
+}
+function isValidInferredTargetName(value) {
+	return /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(value);
+}
 function sortProjects(projects) {
 	return projects.slice().sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
 }
@@ -113,14 +157,17 @@ function resolveExplicitProject(projectRef, projects, workspace) {
 	if (matches.length > 1) throw projectAmbiguousError(projectRef, matches);
 	throw projectNotFoundError(projectRef, workspace);
 }
-function resolveAmbiguousProject(options, matches, projectRef) {
+function resolveAmbiguousProject(options, matches, projectRef, targetNameSource) {
 	if (options.prompt && canPrompt(options.context)) return options.prompt.select({
 		message: "Select a project",
 		choices: sortProjects(matches).map((project) => ({
 			label: `${project.name} (${project.id})`,
 			value: project
 		}))
-	}).then((selected) => rememberIfRequested(options, selected, "prompt"));
+	}).then((selected) => rememberIfRequested(options, selected, "prompt", {
+		targetName: projectRef,
+		targetNameSource
+	}));
 	throw projectAmbiguousError(projectRef, matches);
 }
 function projectMatchesPackageName(project, packageName) {
@@ -129,7 +176,7 @@ function projectMatchesPackageName(project, packageName) {
 async function resolveDurablePlatformMapping() {
 	return null;
 }
-async function rememberIfRequested(options, project, projectSource) {
+async function rememberIfRequested(options, project, projectSource, resolutionDetails) {
 	if (options.remember) await options.context.stateStore.setRememberedProject({
 		id: project.id,
 		name: project.name,
@@ -138,7 +185,10 @@ async function rememberIfRequested(options, project, projectSource) {
 	return {
 		workspace: options.workspace,
 		project: toProjectSummary(project),
-		resolution: { projectSource }
+		resolution: {
+			projectSource,
+			...resolutionDetails
+		}
 	};
 }
 function toProjectSummary(project) {
@@ -148,4 +198,4 @@ function toProjectSummary(project) {
 	};
 }
 //#endregion
-export { resolveProjectTarget, sortProjects };
+export { inferTargetName, projectNotFoundError, resolveProjectTarget, sortProjects };

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,45 +26,23 @@ function serializeAppBuild(result) {
 	return result;
 }
 function renderAppDeploy(context, descriptor, result) {
-	return 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);
+	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) {
-	return 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({

package/dist/presenters/project.js

@@ -105,9 +105,12 @@ function renderGitDisconnect(context, descriptor, result) {
 function formatProjectSource(source) {
 	switch (source) {
 		case "explicit": return "explicit";
+		case "env": return "environment";
+		case "local-pin": return "local pin";
 		case "platform-mapping": return "platform mapping";
 		case "remembered-local": return "remembered local context";
 		case "package-name": return "package name";
+		case "directory-name": return "directory name";
 		case "created": return "created";
 		case "prompt": return "prompt";
 	}