@prisma/cli 3.0.0-beta.3 → 3.0.0-beta.4

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/lib/git/local-branch.js

@@ -0,0 +1,41 @@
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+//#region src/lib/git/local-branch.ts
+async function readLocalGitBranch(cwd, signal) {
+	const headPath = await resolveGitHeadPath(path.join(cwd, ".git"), signal);
+	if (!headPath) return null;
+	try {
+		const head = (await readFile(headPath, {
+			encoding: "utf8",
+			signal
+		})).trim();
+		if (head.startsWith("ref: refs/heads/")) return head.slice(16);
+	} catch (error) {
+		if (signal.aborted) throw error;
+		return null;
+	}
+	return null;
+}
+async function resolveGitHeadPath(gitPath, signal) {
+	signal.throwIfAborted();
+	try {
+		const raw = await readFile(gitPath, {
+			encoding: "utf8",
+			signal
+		});
+		if (raw.startsWith("gitdir:")) return path.join(path.resolve(path.dirname(gitPath), raw.slice(7).trim()), "HEAD");
+	} catch (error) {
+		if (signal.aborted) throw error;
+	}
+	signal.throwIfAborted();
+	try {
+		await access(path.join(gitPath, "HEAD"));
+		signal.throwIfAborted();
+		return path.join(gitPath, "HEAD");
+	} catch (error) {
+		if (signal.aborted) throw error;
+		return null;
+	}
+}
+//#endregion
+export { readLocalGitBranch };

package/dist/presenters/app-env.js

@@ -2,8 +2,18 @@ import { renderList, renderShow, serializeList } from "../output/patterns.js";
 //#region src/presenters/app-env.ts
 function scopeLabel(scope) {
 	if (scope.kind === "role") return scope.role ?? "unknown";
+	if (scope.kind === "overview") return "overview";
 	return `branch:${scope.branchName ?? scope.branchId ?? "unknown"}`;
 }
+function listTargetLabel(result) {
+	const target = result.target;
+	if (target.source === "overview") return "overview";
+	if (target.branchName) {
+		const suffix = target.branchExists === false ? " (not created yet)" : "";
+		return `branch:${target.branchName} -> ${target.envMap}${suffix}`;
+	}
+	return scopeLabel(result.scope);
+}
 function renderEnvAdd(context, descriptor, result) {
 	return renderShow({
 		title: "Setting a new environment variable.",
@@ -75,8 +85,8 @@ function renderEnvList(context, descriptor, result) {
 		title: "Listing environment variables for the selected scope.",
 		descriptor,
 		parentContext: {
-			key: "scope",
-			value: scopeLabel(result.scope)
+			key: "target",
+			value: listTargetLabel(result)
 		},
 		items: result.variables.map((variable) => ({
 			noun: "variable",
@@ -91,8 +101,9 @@ function serializeEnvList(result) {
 	return {
 		projectId: result.projectId,
 		scope: result.scope,
+		target: result.target,
 		...serializeList({
-			context: { scope: scopeLabel(result.scope) },
+			context: { target: listTargetLabel(result) },
 			items: result.variables.map((variable) => ({
 				noun: "variable",
 				label: `${variable.key} (${variable.source})`,

package/dist/presenters/branch.js

@@ -1,111 +1,39 @@
-import { renderList, renderMutate, renderShow, serializeList } from "../output/patterns.js";
+import { formatColumns } from "../shell/ui.js";
+import { formatDescriptorLabel } from "../shell/command-meta.js";
 //#region src/presenters/branch.ts
 function renderBranchList(context, descriptor, result) {
-	return renderList({
-		title: "Listing branches for the resolved project.",
-		descriptor,
-		parentContext: {
-			key: "project",
-			value: result.projectName ?? "not resolved"
-		},
-		items: result.branches.map((branch) => ({
-			noun: "branch",
-			label: branch.name,
-			id: branch.id,
-			status: branch.active ? "active" : null
-		})),
-		emptyMessage: "No branches found."
-	}, context.ui);
+	const ui = context.ui;
+	const lines = [`${ui.strong(formatDescriptorLabel(descriptor))} ${ui.dim("→")} ${ui.dim("Listing branches for the resolved project.")}`, ""];
+	const rail = ui.dim("│");
+	lines.push(`${rail}  ${ui.accent("project:")}  ${result.projectName}`);
+	lines.push(rail);
+	if (result.branches.length === 0) {
+		lines.push(`${rail}  ${ui.dim("No branches found.")}`);
+		return lines;
+	}
+	const widths = [
+		Math.max(4, ...result.branches.map((branch) => branch.name.length)),
+		Math.max(4, ...result.branches.map((branch) => branch.role.length)),
+		Math.max(7, ...result.branches.map((branch) => branch.envMap.length))
+	];
+	lines.push(`${rail}  ${ui.accent(formatColumns([
+		"Name",
+		"Role",
+		"Env map"
+	], widths))}`);
+	for (const branch of result.branches) lines.push(`${rail}  ${formatColumns([
+		branch.name,
+		branch.role,
+		branch.envMap
+	], widths)}`);
+	return lines;
 }
 function serializeBranchList(result) {
-	return serializeList({
-		context: { project: result.projectName ?? "not resolved" },
-		items: result.branches.map((branch) => ({
-			noun: "branch",
-			label: branch.name,
-			id: branch.id,
-			status: branch.active ? "active" : null
-		}))
-	});
-}
-function serializeBranchShow(result) {
 	return {
 		projectId: result.projectId,
 		projectName: result.projectName,
-		branch: {
-			name: result.branch.name,
-			kind: result.branch.kind,
-			active: result.branch.active,
-			remoteState: result.branch.remoteState,
-			liveDeployment: result.branch.liveDeployment
-		}
+		branches: result.branches
 	};
 }
-function renderBranchShow(context, descriptor, result) {
-	const fields = [
-		{
-			key: "project",
-			value: result.projectName ?? "not resolved",
-			tone: result.projectName ? "default" : "dim"
-		},
-		{
-			key: "branch",
-			value: result.branch.name,
-			tone: result.branch.active ? "success" : "default"
-		},
-		{
-			key: "kind",
-			value: result.branch.kind
-		}
-	];
-	if (result.branch.liveDeployment) {
-		fields.push({
-			key: "status",
-			value: result.branch.liveDeployment.status,
-			tone: toneForDeploymentStatus(result.branch.liveDeployment.status)
-		});
-		if (result.branch.liveDeployment.url) fields.push({
-			key: "url",
-			value: result.branch.liveDeployment.url,
-			tone: "link"
-		});
-	} else if (!result.branch.remoteState) fields.push({
-		key: "remote state",
-		value: "not created yet",
-		tone: "dim"
-	});
-	return renderShow({
-		title: "Showing the current active branch context.",
-		descriptor,
-		fields
-	}, context.ui);
-}
-function toneForDeploymentStatus(status) {
-	if (status === "ready" || status === "active" || status === "healthy") return "success";
-	if (status === "pending" || status === "building" || status === "starting") return "warning";
-	if (status === "failed" || status === "error") return "error";
-	return "default";
-}
-function renderBranchUse(context, descriptor, result) {
-	return renderMutate({
-		title: "Changing the local default branch context.",
-		descriptor,
-		context: [{
-			key: "project",
-			value: result.projectName ?? "not resolved",
-			tone: result.projectName ? "default" : "dim"
-		}, {
-			key: "branch",
-			value: result.branch.name
-		}],
-		operationDescription: "Applying active branch change",
-		operationCount: 1,
-		details: ["Active branch updated in local CLI state for this repo."],
-		alerts: result.branch.kind === "production" ? [{
-			tone: "warning",
-			text: "Production is protected and durable. Use with care"
-		}] : void 0
-	}, context.ui);
-}
 //#endregion
-export { renderBranchList, renderBranchShow, renderBranchUse, serializeBranchList, serializeBranchShow };
+export { renderBranchList, serializeBranchList };

package/dist/shell/command-meta.js

@@ -69,8 +69,8 @@ const DESCRIPTORS = [
 	{
 		id: "branch",
 		path: ["prisma", "branch"],
-		description: "View your active Platform branches",
-		examples: ["prisma-cli branch list", "prisma-cli branch show"]
+		description: "View your Platform branches",
+		examples: ["prisma-cli branch list"]
 	},
 	{
 		id: "git",
@@ -153,29 +153,9 @@ const DESCRIPTORS = [
 			"branch",
 			"list"
 		],
-		description: "List active Platform branches for the resolved project",
+		description: "List Platform branches for the resolved project",
 		examples: ["prisma-cli branch list", "prisma-cli branch list --json"]
 	},
-	{
-		id: "branch.show",
-		path: [
-			"prisma",
-			"branch",
-			"show"
-		],
-		description: "Show the Platform branch matching your current Git branch",
-		examples: ["prisma-cli branch show", "prisma-cli branch show --json"]
-	},
-	{
-		id: "branch.use",
-		path: [
-			"prisma",
-			"branch",
-			"use"
-		],
-		description: "Change the local default branch context.",
-		examples: ["prisma-cli branch use", "prisma-cli branch use production"]
-	},
 	{
 		id: "app.build",
 		path: [
@@ -216,6 +196,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"
 		]
@@ -378,7 +359,7 @@ const DESCRIPTORS = [
 		],
 		description: "Manage environment variables for the active project",
 		examples: [
-			"prisma-cli project env list --role production",
+			"prisma-cli project env list",
 			"prisma-cli project env add STRIPE_KEY=sk_test_xxx --role production",
 			"prisma-cli project env add DATABASE_URL=postgresql://branch --branch feature/foo",
 			"prisma-cli project env remove STRIPE_KEY --role preview"
@@ -425,6 +406,7 @@ const DESCRIPTORS = [
 		],
 		description: "List environment variable metadata for a scope (no values).",
 		examples: [
+			"prisma-cli project env list",
 			"prisma-cli project env list --role production",
 			"prisma-cli project env list --role preview",
 			"prisma-cli project env list --branch feature/foo"

package/dist/shell/ui.js

@@ -48,6 +48,9 @@ function renderNextSteps(steps) {
 		...steps.map((step) => `- ${step}`)
 	];
 }
+function formatColumns(columns, widths) {
+	return columns.map((value, index) => padDisplay(value, widths[index])).join("   ").trimEnd();
+}
 function wrapText(text, width, indent = "") {
 	return wrapAnsi(text, width, {
 		hard: false,
@@ -74,4 +77,4 @@ function formatHeaderValue(ui, row) {
 	return value;
 }
 //#endregion
-export { createShellUi, maskValue, padDisplay, renderCommandHeader, renderNextSteps, renderSummaryLine, wrapText };
+export { createShellUi, formatColumns, maskValue, padDisplay, renderCommandHeader, renderNextSteps, renderSummaryLine, wrapText };

package/dist/use-cases/branch.js

@@ -1,34 +1,19 @@
 //#region src/use-cases/branch.ts
 function createBranchUseCases(dependencies) {
-	return {
-		list: async () => {
-			const [projectId, activeBranch] = await Promise.all([dependencies.projectStateGateway.readRememberedProjectId(), dependencies.branchStateGateway.readActiveBranch()]);
-			const remoteBranches = await listRemoteBranches(dependencies.branchGateway, projectId);
-			return {
-				projectId,
-				projectName: resolveProjectName(dependencies.projectGateway, projectId),
-				activeBranch,
-				branches: buildBranchSummaries(activeBranch, remoteBranches)
-			};
-		},
-		show: async () => {
-			const [projectId, activeBranch] = await Promise.all([dependencies.projectStateGateway.readRememberedProjectId(), dependencies.branchStateGateway.readActiveBranch()]);
-			return {
-				projectId,
-				projectName: resolveProjectName(dependencies.projectGateway, projectId),
-				branch: buildBranchDetail(dependencies.branchGateway, projectId, activeBranch)
-			};
-		},
-		use: async (branchName) => {
-			await dependencies.branchStateGateway.writeActiveBranch(branchName);
-			const projectId = await dependencies.projectStateGateway.readRememberedProjectId();
-			return {
-				projectId,
-				projectName: resolveProjectName(dependencies.projectGateway, projectId),
-				branch: buildBranchDetail(dependencies.branchGateway, projectId, branchName)
-			};
-		}
-	};
+	return { list: async () => {
+		const projectId = await dependencies.projectStateGateway.readRememberedProjectId();
+		if (!projectId) return {
+			projectId: "",
+			projectName: "not resolved",
+			branches: []
+		};
+		const remoteBranches = await listRemoteBranches(dependencies.branchGateway, projectId);
+		return {
+			projectId,
+			projectName: resolveProjectName(dependencies.projectGateway, projectId) ?? "not resolved",
+			branches: buildBranchSummaries(remoteBranches)
+		};
+	} };
 }
 function resolveProjectName(projectGateway, projectId) {
 	if (!projectId) return null;
@@ -38,38 +23,13 @@ async function listRemoteBranches(branchGateway, projectId) {
 	if (!projectId) return [];
 	return branchGateway.listBranchesForProject(projectId);
 }
-function buildBranchSummaries(activeBranch, remoteBranches) {
-	const byName = /* @__PURE__ */ new Map();
-	for (const branch of remoteBranches) byName.set(branch.name, {
+function buildBranchSummaries(remoteBranches) {
+	return sortBranches(remoteBranches.map((branch) => ({
 		id: branch.id,
 		name: branch.name,
-		kind: branch.kind,
-		active: activeBranch === branch.name,
-		remoteState: true
-	});
-	if (!byName.has(activeBranch)) byName.set(activeBranch, {
-		id: activeBranch,
-		name: activeBranch,
-		kind: toBranchKind(activeBranch),
-		active: true,
-		remoteState: false
-	});
-	return sortBranches([...byName.values()]);
-}
-function buildBranchDetail(branchGateway, projectId, branchName) {
-	const kind = toBranchKind(branchName);
-	const remoteBranch = projectId ? branchGateway.getBranchForProject(projectId, branchName) : void 0;
-	return {
-		name: branchName,
-		kind,
-		active: true,
-		remoteState: Boolean(remoteBranch),
-		liveDeployment: remoteBranch && remoteBranch.currentDeploymentId ? toLiveDeployment(branchGateway.getDeployment(remoteBranch.currentDeploymentId)) : null
-	};
-}
-function toBranchKind(name) {
-	if (name === "production") return "production";
-	return "preview";
+		role: branch.role,
+		envMap: branch.role
+	})));
 }
 function sortBranches(branches) {
 	return branches.slice().sort((left, right) => {
@@ -80,16 +40,8 @@ function sortBranches(branches) {
 	});
 }
 function branchOrder(branch) {
-	if (branch.name === "production") return 0;
+	if (branch.role === "production") return 0;
 	return 1;
 }
-function toLiveDeployment(deployment) {
-	if (!deployment) return null;
-	return {
-		id: deployment.id,
-		status: deployment.status,
-		url: deployment.url
-	};
-}
 //#endregion
 export { createBranchUseCases };

package/dist/use-cases/create-cli-gateways.js

@@ -29,16 +29,9 @@ function createCliUseCaseGateways(context) {
 			getProjectForWorkspace: (workspaceId, projectId) => context.api.getProjectForWorkspace(workspaceId, projectId)
 		},
 		branchGateway: {
-			listBranchesForProject: (projectId) => context.api.listBranchesForProject(projectId).map((branch) => ({
-				...branch,
-				kind: branch.name === "production" ? "production" : "preview"
-			})),
+			listBranchesForProject: (projectId) => context.api.listBranchesForProject(projectId),
 			getBranchForProject: (projectId, name) => {
-				const branch = context.api.getBranchForProject(projectId, name);
-				return branch ? {
-					...branch,
-					kind: branch.name === "production" ? "production" : "preview"
-				} : void 0;
+				return context.api.getBranchForProject(projectId, name);
 			},
 			getDeployment: (deploymentId) => context.api.getDeployment(deploymentId)
 		},
@@ -55,14 +48,6 @@ function createCliUseCaseGateways(context) {
 			clearAuthSession: async () => {
 				await context.stateStore.clearAuthSession();
 			}
-		},
-		branchStateGateway: {
-			readActiveBranch: async () => {
-				return (await context.stateStore.read()).branch.active;
-			},
-			writeActiveBranch: async (branchName) => {
-				await context.stateStore.setActiveBranch(branchName);
-			}
 		}
 	};
 }

package/package.json

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