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

package/dist/controllers/app-env.js

@@ -1,38 +1,38 @@
 import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../shell/errors.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
 import { resolveProjectTarget } from "../lib/project/resolution.js";
+import { readLocalGitBranch } from "../lib/git/local-branch.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
 import { listRealWorkspaceProjects } from "./project.js";
 import { formatScopeLabel, parseKeyValuePositional, resolveEnvScope } from "../lib/app/env-config.js";
+import { readEnvFileAssignments } from "../lib/app/env-file.js";
+import { apiCallError, findVariableByNaturalKey, toMetadata } from "./app-env-api.js";
+import { runEnvAddFile, runEnvUpdateFile } from "./app-env-file.js";
 //#region src/controllers/app-env.ts
-function defaultRoleScope() {
-	return {
-		kind: "role",
-		role: "production"
-	};
-}
 async function runEnvAdd(context, rawAssignment, flags) {
-	const { key, value } = parseKeyValuePositional(rawAssignment, "add", context.runtime.env);
+	const source = resolveEnvWriteSource(rawAssignment, flags.filePath, "add");
 	const scope = resolveEnvScope(flags, {
 		requireExplicit: true,
 		command: "add"
 	});
-	if (!scope) throw usageError(`prisma-cli project env add requires --role or --branch`, "Writing without an explicit scope is rejected.", "Pass --role production, --role preview, or --branch <git-name>.", [`prisma-cli project env add ${key}=${value} --role production`], "app");
+	if (!scope) throw usageError(`prisma-cli project env add requires --role or --branch`, "Writing without an explicit scope is rejected.", "Pass --role production, --role preview, or --branch <git-name>.", ["prisma-cli project env add KEY=value --role production"], "app");
+	const input = await resolveEnvWriteInput(context, source, "add");
 	const { client, projectId } = await requireClientAndProject(context, flags.projectRef, "project env add");
 	const resolved = await resolveScopeToApi(client, projectId, scope, {
 		createBranchIfMissing: true,
 		signal: context.runtime.signal
 	});
-	if (await findVariableByNaturalKey(client, projectId, key, resolved, context.runtime.signal)) throw new CliError({
+	if (input.kind === "file") return runEnvAddFile(context, client, projectId, resolved, input.filePath, input.assignments);
+	if (await findVariableByNaturalKey(client, projectId, input.key, resolved, context.runtime.signal)) throw new CliError({
 		code: "ENV_VARIABLE_ALREADY_EXISTS",
 		domain: "app",
-		summary: `Variable "${key}" already exists in ${formatScopeLabel(scope)}`,
+		summary: `Variable "${input.key}" already exists in ${formatScopeLabel(scope)}`,
 		why: "A variable with this key already exists in the targeted scope.",
 		fix: "Use `prisma-cli project env update` to change an existing variable's value.",
 		exitCode: 1,
-		nextSteps: [`prisma-cli project env update ${key}=<new-value> ${formatScopeFlag(scope)}`]
+		nextSteps: [`prisma-cli project env update ${input.key}=<new-value> ${formatScopeFlag(scope)}`]
 	});
-	const warnings = scope.kind === "branch" && !await findVariableByNaturalKey(client, projectId, key, {
+	const warnings = scope.kind === "branch" && !await findVariableByNaturalKey(client, projectId, input.key, {
 		scope: {
 			kind: "role",
 			role: "preview"
@@ -45,18 +45,18 @@ async function runEnvAdd(context, rawAssignment, flags) {
 			class: "preview",
 			branchId: null
 		}
-	}, context.runtime.signal) ? [`Variable "${key}" does not exist in preview. It will only exist on ${formatScopeLabel(scope)}.`] : [];
+	}, context.runtime.signal) ? [`Variable "${input.key}" does not exist in preview. It will only exist on ${formatScopeLabel(scope)}.`] : [];
 	const { data, error, response } = await client.POST("/v1/environment-variables", {
 		body: {
 			projectId,
 			class: resolved.apiTarget.class,
 			...resolved.apiTarget.branchId !== null ? { branchId: resolved.apiTarget.branchId } : {},
-			key,
-			value
+			key: input.key,
+			value: input.value
 		},
 		signal: context.runtime.signal
 	});
-	if (error || !data) throw apiCallError(`Failed to add ${key}`, response, error);
+	if (error || !data) throw apiCallError(`Failed to add ${input.key}`, response, error);
 	return {
 		command: "project.env.add",
 		result: {
@@ -69,33 +69,35 @@ async function runEnvAdd(context, rawAssignment, flags) {
 	};
 }
 async function runEnvUpdate(context, rawAssignment, flags) {
-	const { key, value } = parseKeyValuePositional(rawAssignment, "update", context.runtime.env);
+	const source = resolveEnvWriteSource(rawAssignment, flags.filePath, "update");
 	const scope = resolveEnvScope(flags, {
 		requireExplicit: true,
 		command: "update"
 	});
-	if (!scope) throw usageError(`prisma-cli project env update requires --role or --branch`, "Writing without an explicit scope is rejected.", "Pass --role production, --role preview, or --branch <git-name>.", [`prisma-cli project env update ${key}=${value} --role production`], "app");
+	if (!scope) throw usageError(`prisma-cli project env update requires --role or --branch`, "Writing without an explicit scope is rejected.", "Pass --role production, --role preview, or --branch <git-name>.", ["prisma-cli project env update KEY=value --role production"], "app");
+	const input = await resolveEnvWriteInput(context, source, "update");
 	const { client, projectId } = await requireClientAndProject(context, flags.projectRef, "project env update");
 	const resolved = await resolveScopeToApi(client, projectId, scope, {
 		createBranchIfMissing: false,
 		signal: context.runtime.signal
 	});
-	const existing = await findVariableByNaturalKey(client, projectId, key, resolved, context.runtime.signal);
+	if (input.kind === "file") return runEnvUpdateFile(context, client, projectId, resolved, input.filePath, input.assignments);
+	const existing = await findVariableByNaturalKey(client, projectId, input.key, resolved, context.runtime.signal);
 	if (!existing) throw new CliError({
 		code: "ENV_VARIABLE_NOT_FOUND",
 		domain: "app",
-		summary: `Variable "${key}" not found in ${formatScopeLabel(scope)}`,
+		summary: `Variable "${input.key}" not found in ${formatScopeLabel(scope)}`,
 		why: "No variable with this key exists in the targeted scope.",
 		fix: "Use `prisma-cli project env add` to create a new variable.",
 		exitCode: 1,
-		nextSteps: [`prisma-cli project env add ${key}=<value> ${formatScopeFlag(scope)}`]
+		nextSteps: [`prisma-cli project env add ${input.key}=<value> ${formatScopeFlag(scope)}`]
 	});
 	const { data, error, response } = await client.PATCH("/v1/environment-variables/{envVarId}", {
 		params: { path: { envVarId: existing.id } },
-		body: { value },
+		body: { value: input.value },
 		signal: context.runtime.signal
 	});
-	if (error || !data) throw apiCallError(`Failed to update value for ${key}`, response, error);
+	if (error || !data) throw apiCallError(`Failed to update value for ${input.key}`, response, error);
 	return {
 		command: "project.env.update",
 		result: {
@@ -107,26 +109,57 @@ async function runEnvUpdate(context, rawAssignment, flags) {
 		nextSteps: []
 	};
 }
+function resolveEnvWriteSource(rawAssignment, filePath, command) {
+	if (filePath !== void 0 && rawAssignment !== void 0) throw usageError(`prisma-cli project env ${command} accepts either KEY=VALUE or --file`, "The command received both a positional assignment and a dotenv file path.", "Pass one input source.", [`prisma-cli project env ${command} KEY=value --role preview`, `prisma-cli project env ${command} --file .env --role preview`], "app");
+	if (filePath !== void 0) {
+		if (filePath.length === 0) throw usageError(`prisma-cli project env ${command} --file requires a path`, "The --file flag was passed without a file path.", "Pass a readable dotenv file path.", [`prisma-cli project env ${command} --file .env --role preview`], "app");
+		return {
+			kind: "file",
+			filePath
+		};
+	}
+	if (rawAssignment === void 0) throw usageError(`prisma-cli project env ${command} requires KEY=VALUE or --file`, "No environment variable input was supplied.", "Pass a single KEY=VALUE assignment or a dotenv file path.", [`prisma-cli project env ${command} KEY=value --role preview`, `prisma-cli project env ${command} --file .env --role preview`], "app");
+	return {
+		kind: "single",
+		rawAssignment
+	};
+}
+async function resolveEnvWriteInput(context, source, command) {
+	if (source.kind === "file") return {
+		kind: "file",
+		filePath: source.filePath,
+		assignments: await readEnvFileAssignments(context.runtime.cwd, source.filePath, command)
+	};
+	return {
+		kind: "single",
+		...parseKeyValuePositional(source.rawAssignment, command, context.runtime.env)
+	};
+}
 async function runEnvList(context, flags) {
-	const scope = resolveEnvScope(flags, {
+	const explicit = resolveEnvScope(flags, {
 		requireExplicit: false,
 		command: "list"
-	}) ?? defaultRoleScope();
+	});
 	const { client, projectId } = await requireClientAndProject(context, flags.projectRef, "project env list");
-	const resolved = await resolveScopeToApi(client, projectId, scope, {
-		createBranchIfMissing: false,
+	const resolved = await resolveListScopeToApi(client, projectId, explicit, {
+		cwd: context.runtime.cwd,
 		signal: context.runtime.signal
 	});
-	const variables = await listVariables(client, projectId, resolved, context.runtime.signal);
+	const variables = resolved.kind === "scoped" ? await listVariables(client, projectId, {
+		scope: resolved.addScope,
+		descriptor: resolved.descriptor,
+		apiTarget: resolved.apiTarget
+	}, context.runtime.signal) : await listOverviewVariables(client, projectId, context.runtime.signal);
 	return {
 		command: "project.env.list",
 		result: {
 			projectId,
 			scope: resolved.descriptor,
+			target: resolved.target,
 			variables: variables.map((row) => toMetadata(row, resolved.descriptor))
 		},
 		warnings: [],
-		nextSteps: variables.length === 0 ? [`prisma-cli project env add KEY=value ${formatScopeFlag(scope)}`] : []
+		nextSteps: variables.length === 0 ? [`prisma-cli project env add KEY=value ${formatScopeFlag(resolved.addScope)}`] : []
 	};
 }
 async function runEnvRemove(context, key, flags) {
@@ -196,12 +229,12 @@ async function resolveScopeToApi(client, projectId, scope, options) {
 		}
 	};
 	const branch = options.createBranchIfMissing ? await resolveOrCreateBranch(client, projectId, scope.branchName, options.signal) : await resolveExistingBranch(client, projectId, scope.branchName, options.signal);
-	if (branch.isDefault) throw new CliError({
+	if (branch.role === "production") throw new CliError({
 		code: "ENV_BRANCH_SCOPE_IS_PRODUCTION",
 		domain: "app",
-		summary: `Branch "${scope.branchName}" is the default branch`,
+		summary: `Branch "${scope.branchName}" is the production branch`,
 		why: "Production variables are project-level only; branch overrides apply to preview branches.",
-		fix: "Use --role production for the default branch.",
+		fix: "Use --role production for the production branch.",
 		exitCode: 1,
 		nextSteps: ["prisma-cli project env list --role production"]
 	});
@@ -218,6 +251,123 @@ async function resolveScopeToApi(client, projectId, scope, options) {
 		}
 	};
 }
+async function resolveListScopeToApi(client, projectId, explicit, options) {
+	if (explicit) {
+		const resolved = await resolveScopeToApi(client, projectId, explicit, {
+			createBranchIfMissing: false,
+			signal: options.signal
+		});
+		return {
+			kind: "scoped",
+			descriptor: resolved.descriptor,
+			target: targetFromExplicitScope(resolved.descriptor),
+			apiTarget: resolved.apiTarget,
+			addScope: resolved.scope
+		};
+	}
+	const gitBranch = await readLocalGitBranch(options.cwd, options.signal);
+	if (gitBranch) {
+		const branch = (await listBranchesByName(client, projectId, gitBranch, options.signal))[0];
+		if (!branch) return {
+			kind: "scoped",
+			descriptor: {
+				kind: "role",
+				role: "preview"
+			},
+			target: {
+				source: "local-git",
+				branchName: gitBranch,
+				branchExists: false,
+				envMap: "preview"
+			},
+			apiTarget: {
+				class: "preview",
+				branchId: null
+			},
+			addScope: {
+				kind: "branch",
+				branchName: gitBranch
+			}
+		};
+		if (branch.role === "production") return {
+			kind: "scoped",
+			descriptor: {
+				kind: "role",
+				role: "production"
+			},
+			target: {
+				source: "local-git",
+				branchName: branch.gitName,
+				branchId: branch.id,
+				branchRole: branch.role,
+				branchExists: true,
+				envMap: "production"
+			},
+			apiTarget: {
+				class: "production",
+				branchId: null
+			},
+			addScope: {
+				kind: "role",
+				role: "production"
+			}
+		};
+		return {
+			kind: "scoped",
+			descriptor: {
+				kind: "branch",
+				branchName: branch.gitName,
+				branchId: branch.id
+			},
+			target: {
+				source: "local-git",
+				branchName: branch.gitName,
+				branchId: branch.id,
+				branchRole: branch.role,
+				branchExists: true,
+				envMap: "preview"
+			},
+			apiTarget: {
+				class: "preview",
+				branchId: branch.id
+			},
+			addScope: {
+				kind: "branch",
+				branchName: branch.gitName
+			}
+		};
+	}
+	return {
+		kind: "overview",
+		descriptor: { kind: "overview" },
+		target: {
+			source: "overview",
+			envMap: "overview"
+		},
+		addScope: {
+			kind: "role",
+			role: "preview"
+		}
+	};
+}
+function targetFromExplicitScope(scope) {
+	if (scope.kind === "branch") return {
+		source: "explicit",
+		branchName: scope.branchName,
+		branchId: scope.branchId,
+		branchRole: "preview",
+		branchExists: true,
+		envMap: "preview"
+	};
+	if (scope.kind === "role") return {
+		source: "explicit",
+		envMap: scope.role
+	};
+	return {
+		source: "overview",
+		envMap: "overview"
+	};
+}
 function formatScopeFlag(scope) {
 	if (scope.kind === "role") return `--role ${scope.role}`;
 	return `--branch ${scope.branchName}`;
@@ -293,47 +443,45 @@ async function projectHasDefaultBranch(client, projectId, signal) {
 		cursor = result.data.pagination.nextCursor;
 	}
 }
-async function findVariableByNaturalKey(client, projectId, key, resolved, signal) {
-	const { data, error, response } = await client.GET("/v1/environment-variables", {
-		params: { query: {
-			projectId,
-			class: resolved.apiTarget.class,
-			key
-		} },
-		signal
+async function listVariables(client, projectId, resolved, signal) {
+	return materializeEffectiveRows(await collectEnvironmentVariables(client, projectId, signal, {
+		className: resolved.apiTarget.class,
+		filter: (row) => rowMatchesScope(row, resolved)
+	}), resolved);
+}
+async function listOverviewVariables(client, projectId, signal) {
+	return (await collectEnvironmentVariables(client, projectId, signal, { filter: (row) => row.branchId === null && (row.class === "production" || row.class === "preview") })).sort((left, right) => {
+		const roleOrder = roleSortOrder(left.class) - roleSortOrder(right.class);
+		return roleOrder !== 0 ? roleOrder : left.key.localeCompare(right.key);
 	});
-	if (error || !data) throw apiCallError(`Failed to look up ${key}`, response, error);
-	return data.data.filter((row) => rowMatchesExactScope(row, resolved))[0] ?? null;
 }
-async function listVariables(client, projectId, resolved, signal) {
+async function collectEnvironmentVariables(client, projectId, signal, options) {
 	const collected = [];
 	let cursor;
 	while (true) {
-		const query = {
-			projectId,
-			class: resolved.apiTarget.class
-		};
+		const query = { projectId };
+		if (options.className !== void 0) query.class = options.className;
 		if (cursor !== void 0) query.cursor = cursor;
 		const result = await client.GET("/v1/environment-variables", {
 			params: { query },
 			signal
 		});
 		if (result.error || !result.data) throw apiCallError(`Failed to list environment variables`, result.response, result.error);
-		const page = result.data.data.filter((row) => rowMatchesScope(row, resolved));
+		const page = result.data.data.filter(options.filter);
 		collected.push(...page);
 		if (!result.data.pagination.hasMore || !result.data.pagination.nextCursor) break;
 		cursor = result.data.pagination.nextCursor;
 	}
-	return materializeEffectiveRows(collected, resolved);
+	return collected;
+}
+function roleSortOrder(role) {
+	return role === "production" ? 0 : 1;
 }
 function rowMatchesScope(row, resolved) {
 	if (row.class !== resolved.apiTarget.class) return false;
 	if (resolved.apiTarget.branchId === null) return row.branchId === null;
 	return row.branchId === null || row.branchId === resolved.apiTarget.branchId;
 }
-function rowMatchesExactScope(row, resolved) {
-	return row.class === resolved.apiTarget.class && row.branchId === resolved.apiTarget.branchId;
-}
 function materializeEffectiveRows(rows, resolved) {
 	if (resolved.apiTarget.branchId === null) return rows;
 	const byKey = /* @__PURE__ */ new Map();
@@ -341,39 +489,5 @@ function materializeEffectiveRows(rows, resolved) {
 	for (const row of rows) if (row.branchId === resolved.apiTarget.branchId) byKey.set(row.key, row);
 	return [...byKey.values()].sort((left, right) => left.key.localeCompare(right.key));
 }
-function toMetadata(row, requestedScope) {
-	const rowScope = row.branchId === null ? {
-		kind: "role",
-		role: row.class
-	} : requestedScope;
-	return {
-		id: row.id,
-		key: row.key,
-		scope: rowScope,
-		source: formatDescriptorLabel(rowScope),
-		isManagedBySystem: row.isManagedBySystem,
-		updatedAt: row.updatedAt
-	};
-}
-function formatDescriptorLabel(scope) {
-	if (scope.kind === "role") return scope.role ?? "unknown";
-	return `branch:${scope.branchName ?? scope.branchId ?? "unknown"}`;
-}
-function apiCallError(summary, response, error) {
-	const status = response?.status ?? 0;
-	const apiCode = error?.error?.code;
-	const apiMessage = error?.error?.message;
-	const apiHint = error?.error?.hint;
-	if (status === 401 || status === 403) return authRequiredError(["prisma auth login"]);
-	return new CliError({
-		code: apiCode ?? "ENV_API_ERROR",
-		domain: "app",
-		summary,
-		why: apiMessage ?? `The Management API returned status ${status || "unknown"}.`,
-		fix: apiHint ?? "Re-run with --trace for the underlying API response details.",
-		exitCode: 1,
-		nextSteps: []
-	});
-}
 //#endregion
 export { runEnvAdd, runEnvList, runEnvRemove, runEnvUpdate };

package/dist/controllers/app.js

@@ -16,10 +16,13 @@ import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin } from "../l
 import { buildProjectSetupNextActions, inferTargetName, projectNotFoundError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
 import { bindProjectToDirectory, projectCreateFailedError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
 import { promptForProjectSetupChoice } from "../lib/project/interactive-setup.js";
+import { readLocalGitBranch } from "../lib/git/local-branch.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 { maybeSetupBranchDatabase } from "../lib/app/branch-database-deploy.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,10 +161,20 @@ 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);
 	const portMapping = parseDeployPortMapping(String(runtime.port));
+	const branchDatabaseSetup = await maybeSetupBranchDatabase(context, provider, projectId, toBranchDatabaseDeployBranch(target.branch), {
+		db: options?.db,
+		inlineEnvVars: envVars
+	});
 	const progressState = createPreviewDeployProgressState();
 	const deployStartedAt = Date.now();
 	const deployResult = await provider.deployApp({
@@ -192,8 +205,9 @@ async function runAppDeploy(context, appName, options) {
 		result: {
 			workspace: target.workspace,
 			project: target.project,
-			branch: target.branch,
+			branch: toResultBranch(target.branch),
 			resolution: target.resolution,
+			branchDatabase: branchDatabaseSetup.result,
 			app: {
 				id: deployResult.app.id,
 				name: deployResult.app.name
@@ -202,7 +216,7 @@ async function runAppDeploy(context, appName, options) {
 			durationMs: deployDurationMs,
 			localPin: localPinResult
 		},
-		warnings: [],
+		warnings: branchDatabaseSetup.warnings,
 		nextSteps: ["prisma-cli app list-deploys", `prisma-cli app show-deploy ${deployResult.deployment.id}`]
 	};
 }
@@ -749,7 +763,7 @@ async function resolveAppDomainTarget(context, options, commandName = "app domai
 		resultTarget: {
 			workspace: target.workspace,
 			project: target.project,
-			branch: target.branch,
+			branch: toResultBranch(target.branch),
 			app: {
 				id: selectedApp.id,
 				name: selectedApp.name
@@ -1312,6 +1326,7 @@ async function resolveProjectContext(context, client, explicitProject, options)
 	return {
 		...resolved,
 		branch: {
+			id: null,
 			name: branch.name,
 			kind: toBranchKind(branch.name)
 		}
@@ -1322,7 +1337,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 +1346,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 +1359,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 +1372,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 +1387,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 +1398,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,18 +1445,37 @@ 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)
+			id: remoteBranch.id,
+			name: remoteBranch.name,
+			kind: remoteBranch.role
 		}
 	};
 }
 function toBranchKind(name) {
 	return name === "production" || name === "main" ? "production" : "preview";
 }
+function toResultBranch(branch) {
+	return {
+		name: branch.name,
+		kind: branch.kind
+	};
+}
+function toBranchDatabaseDeployBranch(branch) {
+	if (!branch.id) throw new Error(`Deploy branch "${branch.name}" was not resolved remotely.`);
+	return {
+		id: branch.id,
+		name: branch.name,
+		kind: branch.kind
+	};
+}
 function assertExclusiveDeployProjectInputs(options) {
 	const provided = [
 		options.projectRef ? "--project" : null,
@@ -1470,42 +1504,6 @@ async function resolveDeployBranch(context, explicitBranchName) {
 		annotation: "default"
 	};
 }
-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;
-	}
-}
 async function resolveDeployFramework(context, options) {
 	if (options.requestedFramework) return frameworkFromUserFacingValue(options.requestedFramework, "set by --framework");
 	if (options.entrypoint) return {