@prisma/cli 3.0.0-dev.54.1 → 3.0.0-dev.56.1

package/dist/commands/app/index.js

@@ -64,7 +64,7 @@ function createDeployCommand(runtime) {
 		"hono",
 		"tanstack-start",
 		"bun"
-	])).addOption(new Option("--entry <path>", "Entrypoint path for Bun deploys")).addOption(new Option("--http-port <port>", "HTTP port override for the deployed app")).addOption(new Option("--env <name=value>", "Environment variable").argParser(collectRepeatableValues));
+	])).addOption(new Option("--entry <path>", "Entrypoint path for Bun deploys")).addOption(new Option("--http-port <port>", "HTTP port override for the deployed app")).addOption(new Option("--env <name=value>", "Environment variable").argParser(collectRepeatableValues)).addOption(new Option("--prod", "Confirm intent to deploy to production"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
@@ -75,6 +75,7 @@ function createDeployCommand(runtime) {
 		const envAssignments = options.env;
 		const projectRef = options.project;
 		const createProjectName = options.createProject;
+		const prod = options.prod;
 		await runCommand(runtime, "app.deploy", options, (context) => runAppDeploy(context, appName, {
 			projectRef,
 			createProjectName,
@@ -82,7 +83,8 @@ function createDeployCommand(runtime) {
 			entrypoint: entry,
 			framework,
 			httpPort,
-			envAssignments
+			envAssignments,
+			prod: prod === true
 		}), {
 			renderHuman: (context, descriptor, result) => renderAppDeploy(context, descriptor, result),
 			renderJson: (result) => serializeAppDeploy(result)

package/dist/controllers/app.js

@@ -20,6 +20,7 @@ import { PREVIEW_BUILD_TYPES, RESOLVED_PREVIEW_BUILD_TYPES, executePreviewBuild
 import { PREVIEW_DEFAULT_REGION } from "../lib/app/preview-interaction.js";
 import { createPreviewDeployProgress, createPreviewDeployProgressState, createPreviewPromoteProgress } from "../lib/app/preview-progress.js";
 import { PreviewDomainApiError, createPreviewAppProvider } from "../lib/app/preview-provider.js";
+import { enforceProductionDeployGate } from "../lib/app/production-deploy-gate.js";
 import { formatDomainFailureFix } from "../lib/app/domain-guidance.js";
 import { createSelectPromptPort } from "./select-prompt-port.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
@@ -158,6 +159,12 @@ async function runAppDeploy(context, appName, options) {
 	});
 	framework = customized.framework;
 	runtime = customized.runtime;
+	await enforceProductionDeployGate(context, provider, {
+		appId: selectedApp.appId,
+		appName: selectedApp.displayName,
+		branchKind: target.branch.kind,
+		prod: options?.prod === true
+	});
 	const buildType = framework.buildType;
 	assertSupportedEntrypoint(buildType, options?.entrypoint, "deploy");
 	const entrypoint = await resolveDeployEntrypoint(context.runtime.cwd, framework, options?.entrypoint, context.runtime.signal);
@@ -1322,7 +1329,7 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 	if (!workspace) throw workspaceRequiredError();
 	const branch = options.branch ?? await resolveDeployBranch(context, void 0);
 	const projects = await listRealWorkspaceProjects(client, workspace, context.runtime.signal);
-	if (explicitProject) return withDeployBranch({
+	if (explicitProject) return withRemoteDeployBranch(provider, {
 		workspace,
 		project: toProjectSummary(resolveProjectForSetup(explicitProject, projects, workspace)),
 		resolution: {
@@ -1331,11 +1338,11 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 			targetNameSource: "explicit"
 		},
 		localPinAction: "linked"
-	}, branch);
+	}, branch, context.runtime.signal);
 	if (options.createProjectName) {
 		const projectName = options.createProjectName.trim();
 		if (!projectName) throw projectSetupNameRequiredError("app deploy --create-project");
-		return withDeployBranch({
+		return withRemoteDeployBranch(provider, {
 			workspace,
 			project: toProjectSummary(await createProjectForDeploySetup(provider, projectName, workspace, context.runtime.signal)),
 			resolution: {
@@ -1344,12 +1351,12 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 				targetNameSource: "explicit"
 			},
 			localPinAction: "created"
-		}, branch);
+		}, branch, context.runtime.signal);
 	}
 	if (options.envProjectId) {
 		const project = projects.find((candidate) => candidate.id === options.envProjectId);
 		if (!project) throw projectNotFoundError(options.envProjectId, workspace);
-		return withDeployBranch({
+		return withRemoteDeployBranch(provider, {
 			workspace,
 			project: toProjectSummary(project),
 			resolution: {
@@ -1357,14 +1364,14 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 				targetName: options.envProjectId,
 				targetNameSource: "env"
 			}
-		}, branch);
+		}, branch, context.runtime.signal);
 	}
 	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({
+		return withRemoteDeployBranch(provider, {
 			workspace,
 			project: toProjectSummary(project),
 			resolution: {
@@ -1372,10 +1379,10 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 				targetName: project.name,
 				targetNameSource: "local-pin"
 			}
-		}, branch);
+		}, branch, context.runtime.signal);
 	}
 	const platformMapping = await resolveDurablePlatformMapping();
-	if (platformMapping && platformMapping.workspace.id === workspace.id) return withDeployBranch({
+	if (platformMapping && platformMapping.workspace.id === workspace.id) return withRemoteDeployBranch(provider, {
 		workspace,
 		project: toProjectSummary(platformMapping),
 		resolution: {
@@ -1383,8 +1390,8 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 			targetName: platformMapping.name,
 			targetNameSource: "platform-mapping"
 		}
-	}, branch);
-	if (canPrompt(context) && !context.flags.yes) return withDeployBranch(await resolveInteractiveDeployProjectSetup(context, provider, workspace, projects), branch);
+	}, branch, context.runtime.signal);
+	if (canPrompt(context) && !context.flags.yes) return withRemoteDeployBranch(provider, await resolveInteractiveDeployProjectSetup(context, provider, workspace, projects), branch, context.runtime.signal);
 	throw projectSetupRequiredError(projects, await inferTargetName(context.runtime.cwd, context.runtime.signal));
 }
 async function resolveInteractiveDeployProjectSetup(context, provider, workspace, projects) {
@@ -1430,12 +1437,16 @@ async function createProjectForDeploySetup(provider, projectName, workspace, sig
 		workspace
 	};
 }
-function withDeployBranch(target, branch) {
+async function withRemoteDeployBranch(provider, target, branch, signal) {
+	const remoteBranch = await provider.resolveBranch(target.project.id, {
+		branchName: branch.name,
+		signal
+	});
 	return {
 		...target,
 		branch: {
-			name: branch.name,
-			kind: toBranchKind(branch.name)
+			name: remoteBranch.name,
+			kind: remoteBranch.role
 		}
 	};
 }

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

@@ -36,6 +36,18 @@ function createPreviewAppProvider(client, options) {
 				signal: options?.signal
 			});
 		},
+		async resolveBranch(projectId, options) {
+			const branch = await resolveOrCreateBranch(client, {
+				projectId,
+				gitName: options.branchName,
+				signal: options.signal
+			});
+			return {
+				id: branch.id,
+				name: branch.gitName,
+				role: branch.role
+			};
+		},
 		async removeApp(appId, options) {
 			const appResult = await sdk.showService({
 				serviceId: appId,
@@ -316,17 +328,19 @@ async function listBranches(client, options) {
 		signal: options.signal
 	});
 	if (result.error || !result.data) throw apiCallError("Failed to list branches", result.response, result.error);
-	return result.data.data;
+	return result.data.data.map((branch) => ({
+		id: branch.id,
+		gitName: branch.gitName,
+		isDefault: branch.isDefault,
+		role: branch.role
+	}));
 }
 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"
-		},
+		body: { gitName: options.gitName },
 		signal: options.signal
 	});
 	if (result.error || !result.data) {
@@ -336,7 +350,13 @@ async function resolveOrCreateBranch(client, options) {
 		}
 		throw apiCallError(`Failed to create branch "${options.gitName}"`, result.response, result.error);
 	}
-	return result.data.data;
+	const branch = result.data.data;
+	return {
+		id: branch.id,
+		gitName: branch.gitName,
+		isDefault: branch.isDefault,
+		role: branch.role
+	};
 }
 async function listComputeServices(client, options) {
 	const services = [];

package/dist/lib/app/production-deploy-gate.js

@@ -0,0 +1,160 @@
+import { CliError } from "../../shell/errors.js";
+import { canPrompt } from "../../shell/runtime.js";
+import { confirmPrompt } from "../../shell/prompt.js";
+//#region src/lib/app/production-deploy-gate.ts
+async function enforceProductionDeployGate(context, provider, options) {
+	if (options.branchKind !== "production") return;
+	if (!options.appId) {
+		renderFirstProductionDeployLine(context, options.appName);
+		return;
+	}
+	const currentLiveDeployment = resolveCurrentProductionDeployment(await provider.listDeployments(options.appId).catch((error) => {
+		throw productionDeployInspectionFailedError(error);
+	}));
+	if (!currentLiveDeployment) {
+		renderFirstProductionDeployLine(context, options.appName);
+		return;
+	}
+	if (!options.prod) throw productionDeployRequiresFlagError();
+	if (context.flags.yes) {
+		renderProductionDeployYesLine(context);
+		return;
+	}
+	if (!canPrompt(context)) throw productionDeployConfirmationRequiredError(options.appName);
+	renderProductionDeployConfirmation(context, currentLiveDeployment);
+	if (!await confirmPrompt({
+		input: context.runtime.stdin,
+		output: context.output.stderr,
+		message: "Deploy to production?",
+		initialValue: false
+	})) throw productionDeployCancelledError();
+}
+function resolveCurrentProductionDeployment(result) {
+	if (result.deployments.length === 0) return null;
+	if (result.app.liveDeploymentId) {
+		const live = result.deployments.find((deployment) => deployment.id === result.app.liveDeploymentId);
+		if (live) return live;
+	}
+	return result.deployments.find((deployment) => deployment.live === true) ?? result.deployments[0] ?? null;
+}
+function renderFirstProductionDeployLine(context, appName) {
+	if (context.flags.json || context.flags.quiet) return;
+	context.output.stderr.write(`First deploy of "${appName}" -- promoting to production.\n\n`);
+}
+function renderProductionDeployYesLine(context) {
+	if (context.flags.json || context.flags.quiet) return;
+	context.output.stderr.write("Deploying to production (--prod --yes).\n\n");
+}
+function renderProductionDeployConfirmation(context, currentLiveDeployment) {
+	if (context.flags.json || context.flags.quiet) return;
+	const lines = [
+		"This will deploy to production and replace the live deployment.",
+		"",
+		`  Current live:  ${currentLiveDeployment.id} deployed ${formatDeploymentAge(currentLiveDeployment.createdAt)}`,
+		"  New deploy:    will be built from your local code",
+		""
+	];
+	context.output.stderr.write(`${lines.join("\n")}\n`);
+}
+function formatDeploymentAge(createdAt) {
+	const createdAtMs = Date.parse(createdAt);
+	if (!Number.isFinite(createdAtMs)) return createdAt;
+	const elapsedMs = Math.max(0, Date.now() - createdAtMs);
+	for (const unit of [
+		{
+			label: "day",
+			ms: 1440 * 60 * 1e3
+		},
+		{
+			label: "hour",
+			ms: 3600 * 1e3
+		},
+		{
+			label: "minute",
+			ms: 60 * 1e3
+		}
+	]) if (elapsedMs >= unit.ms) {
+		const value = Math.floor(elapsedMs / unit.ms);
+		return `${value} ${unit.label}${value === 1 ? "" : "s"} ago`;
+	}
+	return "less than a minute ago";
+}
+function productionDeployRequiresFlagError() {
+	return new CliError({
+		code: "PROD_DEPLOY_REQUIRES_FLAG",
+		domain: "app",
+		summary: "Production deploy requires --prod",
+		why: "The resolved Branch is production and this App already has a production deployment.",
+		fix: "Re-run with --prod, or deploy from a preview Branch.",
+		exitCode: 2,
+		nextActions: [{
+			kind: "run-command",
+			journey: "deploy-app",
+			label: "Deploy to production",
+			command: "prisma-cli app deploy --prod"
+		}, {
+			kind: "run-command",
+			journey: "deploy-app",
+			label: "Create a preview branch",
+			commands: ["git checkout -b <branch-name>", "prisma-cli app deploy"]
+		}],
+		humanLines: [
+			"This would deploy to production.",
+			"",
+			"Production deploys require explicit intent. Re-run with:",
+			"",
+			"  prisma app deploy --prod",
+			"",
+			"Or deploy a preview from a feature branch:",
+			"",
+			"  git checkout -b <branch-name>",
+			"  prisma app deploy"
+		]
+	});
+}
+function productionDeployConfirmationRequiredError(appName) {
+	return new CliError({
+		code: "CONFIRMATION_REQUIRED",
+		domain: "app",
+		summary: "Production deploy requires confirmation in the current mode",
+		why: "This command cannot prompt for production deploy confirmation in the current mode.",
+		fix: `Pass --prod --yes to confirm deployment of "${appName}" to production.`,
+		exitCode: 1,
+		nextSteps: ["prisma-cli app deploy --prod --yes"],
+		nextActions: [{
+			kind: "run-command",
+			journey: "deploy-app",
+			label: "Deploy to production non-interactively",
+			command: "prisma-cli app deploy --prod --yes"
+		}]
+	});
+}
+function productionDeployCancelledError() {
+	return new CliError({
+		code: "CONFIRMATION_REQUIRED",
+		domain: "app",
+		summary: "Production deploy cancelled",
+		why: null,
+		fix: null,
+		exitCode: 0,
+		humanLines: ["Cancelled."]
+	});
+}
+function productionDeployInspectionFailedError(error) {
+	return new CliError({
+		code: "DEPLOY_FAILED",
+		domain: "app",
+		summary: "Failed to inspect production deployments",
+		why: error instanceof Error ? error.message : String(error),
+		fix: "Retry the command, or rerun with --trace for more detailed diagnostics.",
+		debug: formatDebugDetails(error),
+		exitCode: 1,
+		nextSteps: ["prisma-cli app list-deploys"]
+	});
+}
+function formatDebugDetails(error) {
+	if (error instanceof Error) return error.stack ?? error.message;
+	return typeof error === "string" ? error : null;
+}
+//#endregion
+export { enforceProductionDeployGate };

package/dist/shell/command-meta.js

@@ -216,6 +216,7 @@ const DESCRIPTORS = [
 			"prisma-cli app deploy --app my-app --env DATABASE_URL=postgresql://example",
 			"prisma-cli app deploy --app my-app --framework nextjs --http-port 3000",
 			"prisma-cli app deploy --branch feat-login --framework hono",
+			"prisma-cli app deploy --prod --yes",
 			"pnpm dlx skills@latest add prisma/prisma-cli/skills#cli-v<cli-version> --all",
 			"prisma-cli app deploy --framework bun --entry src/server.ts"
 		]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-dev.54.1",
+  "version": "3.0.0-dev.56.1",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {