@prisma/cli 3.0.0-dev.61.1 → 3.0.0-dev.63.1

package/README.md

@@ -57,6 +57,7 @@ Useful next commands:
 npx prisma-cli app logs
 npx prisma-cli app open
 npx prisma-cli project env add DATABASE_URL=postgresql://example --role preview
+npx prisma-cli project env add --file .env --role preview
 npx prisma-cli project env list
 npx prisma-cli project env list --role preview
 ```

package/dist/commands/env.js

@@ -17,16 +17,18 @@ function createEnvCommand(runtime) {
 }
 function createEnvAddCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("add"), runtime), "project.env.add");
-	command.argument("<assignment>", "Variable assignment as KEY=VALUE or KEY from the current environment").addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--branch <git-name>", "Preview branch override scope")).addOption(new Option("--project <id-or-name>", "Project id or name"));
+	command.argument("[assignment]", "Variable assignment as KEY=VALUE or KEY from the current environment").addOption(new Option("--file <path>", "Read KEY=VALUE assignments from a dotenv file")).addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--branch <git-name>", "Preview branch override scope")).addOption(new Option("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (assignment, options) => {
 		const roleName = options.role;
 		const branchName = options.branch;
 		const projectRef = options.project;
+		const filePath = options.file;
 		await runCommand(runtime, "project.env.add", options, (context) => runEnvAdd(context, assignment, {
 			roleName,
 			branchName,
-			projectRef
+			projectRef,
+			filePath
 		}), {
 			renderHuman: (context, descriptor, result) => renderEnvAdd(context, descriptor, result),
 			renderJson: (result) => serializeEnvAdd(result)
@@ -36,16 +38,18 @@ function createEnvAddCommand(runtime) {
 }
 function createEnvUpdateCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("update"), runtime), "project.env.update");
-	command.argument("<assignment>", "Variable assignment as KEY=VALUE or KEY from the current environment").addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--branch <git-name>", "Preview branch override scope")).addOption(new Option("--project <id-or-name>", "Project id or name"));
+	command.argument("[assignment]", "Variable assignment as KEY=VALUE or KEY from the current environment").addOption(new Option("--file <path>", "Read KEY=VALUE assignments from a dotenv file")).addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--branch <git-name>", "Preview branch override scope")).addOption(new Option("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (assignment, options) => {
 		const roleName = options.role;
 		const branchName = options.branch;
 		const projectRef = options.project;
+		const filePath = options.file;
 		await runCommand(runtime, "project.env.update", options, (context) => runEnvUpdate(context, assignment, {
 			roleName,
 			branchName,
-			projectRef
+			projectRef,
+			filePath
 		}), {
 			renderHuman: (context, descriptor, result) => renderEnvUpdate(context, descriptor, result),
 			renderJson: (result) => serializeEnvUpdate(result)

package/dist/controllers/app-env-api.js

@@ -0,0 +1,54 @@
+import { CliError, authRequiredError } from "../shell/errors.js";
+//#region src/controllers/app-env-api.ts
+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
+	});
+	if (error || !data) throw apiCallError(`Failed to look up ${key}`, response, error);
+	return data.data.filter((row) => rowMatchesExactScope(row, resolved))[0] ?? null;
+}
+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 rowMatchesExactScope(row, resolved) {
+	return row.class === resolved.apiTarget.class && row.branchId === resolved.apiTarget.branchId;
+}
+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: []
+	});
+}
+function formatDescriptorLabel(scope) {
+	if (scope.kind === "role") return scope.role ?? "unknown";
+	if (scope.kind === "overview") return "overview";
+	return `branch:${scope.branchName ?? scope.branchId ?? "unknown"}`;
+}
+//#endregion
+export { apiCallError, findVariableByNaturalKey, toMetadata };

package/dist/controllers/app-env-file.js

@@ -0,0 +1,179 @@
+import { CliError } from "../shell/errors.js";
+import { formatScopeLabel } from "../lib/app/env-config.js";
+import { apiCallError, findVariableByNaturalKey, toMetadata } from "./app-env-api.js";
+//#region src/controllers/app-env-file.ts
+async function runEnvAddFile(context, client, projectId, resolved, filePath, assignments) {
+	const existing = await findVariablesByNaturalKey(client, projectId, assignments.map((assignment) => assignment.key), resolved, context.runtime.signal);
+	const existingKeys = assignments.map((assignment) => assignment.key).filter((key) => existing.has(key));
+	if (existingKeys.length > 0) throw new CliError({
+		code: "ENV_VARIABLE_ALREADY_EXISTS",
+		domain: "app",
+		summary: `${existingKeys.length} environment variable(s) already exist in ${formatScopeLabel(resolved.scope)}`,
+		why: `Existing keys: ${formatKeyList(existingKeys)}.`,
+		fix: "Split the input file by key state: update existing keys and add new keys separately.",
+		exitCode: 1,
+		nextSteps: splitFileNextSteps(filePath, resolved.scope, {
+			existingKeys,
+			first: "update-existing"
+		}),
+		meta: { keys: existingKeys }
+	});
+	const warnings = await missingPreviewDefaultWarnings(client, projectId, resolved.scope, assignments.map((assignment) => assignment.key), context.runtime.signal);
+	const variables = [];
+	for (const assignment of assignments) try {
+		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: assignment.key,
+				value: assignment.value
+			},
+			signal: context.runtime.signal
+		});
+		if (error || !data) throw apiCallError(`Failed to add ${assignment.key}`, response, error);
+		variables.push(toMetadata(data.data, resolved.descriptor));
+	} catch (error) {
+		throw envFileApplyFailedError("add", filePath, resolved.scope, assignment.key, variables, error);
+	}
+	return {
+		command: "project.env.add",
+		result: {
+			projectId,
+			scope: resolved.descriptor,
+			variables,
+			file: {
+				path: filePath,
+				count: variables.length
+			}
+		},
+		warnings,
+		nextSteps: []
+	};
+}
+async function runEnvUpdateFile(context, client, projectId, resolved, filePath, assignments) {
+	const existing = await findVariablesByNaturalKey(client, projectId, assignments.map((assignment) => assignment.key), resolved, context.runtime.signal);
+	const missingKeys = assignments.map((assignment) => assignment.key).filter((key) => !existing.has(key));
+	if (missingKeys.length > 0) throw new CliError({
+		code: "ENV_VARIABLE_NOT_FOUND",
+		domain: "app",
+		summary: `${missingKeys.length} environment variable(s) not found in ${formatScopeLabel(resolved.scope)}`,
+		why: `Missing keys: ${formatKeyList(missingKeys)}.`,
+		fix: "Split the input file by key state: add missing keys and update existing keys separately.",
+		exitCode: 1,
+		nextSteps: splitFileNextSteps(filePath, resolved.scope, {
+			missingKeys,
+			first: "add-missing"
+		}),
+		meta: { keys: missingKeys }
+	});
+	const variables = [];
+	for (const assignment of assignments) {
+		const existingVariable = existing.get(assignment.key);
+		if (!existingVariable) continue;
+		try {
+			const { data, error, response } = await client.PATCH("/v1/environment-variables/{envVarId}", {
+				params: { path: { envVarId: existingVariable.id } },
+				body: { value: assignment.value },
+				signal: context.runtime.signal
+			});
+			if (error || !data) throw apiCallError(`Failed to update value for ${assignment.key}`, response, error);
+			variables.push(toMetadata(data.data, resolved.descriptor));
+		} catch (error) {
+			throw envFileApplyFailedError("update", filePath, resolved.scope, assignment.key, variables, error);
+		}
+	}
+	return {
+		command: "project.env.update",
+		result: {
+			projectId,
+			scope: resolved.descriptor,
+			variables,
+			file: {
+				path: filePath,
+				count: variables.length
+			}
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function findVariablesByNaturalKey(client, projectId, keys, resolved, signal) {
+	const found = /* @__PURE__ */ new Map();
+	for (const key of keys) {
+		const row = await findVariableByNaturalKey(client, projectId, key, resolved, signal);
+		if (row) found.set(key, row);
+	}
+	return found;
+}
+async function missingPreviewDefaultWarnings(client, projectId, scope, keys, signal) {
+	if (scope.kind !== "branch") return [];
+	const previewScope = {
+		scope: {
+			kind: "role",
+			role: "preview"
+		},
+		descriptor: {
+			kind: "role",
+			role: "preview"
+		},
+		apiTarget: {
+			class: "preview",
+			branchId: null
+		}
+	};
+	const missing = [];
+	for (const key of keys) if (!await findVariableByNaturalKey(client, projectId, key, previewScope, signal)) missing.push(key);
+	if (missing.length === 0) return [];
+	if (missing.length === 1) return [`Variable "${missing[0]}" does not exist in preview. It will only exist on ${formatScopeLabel(scope)}.`];
+	return [`Variables ${formatKeyList(missing)} do not exist in preview. They will only exist on ${formatScopeLabel(scope)}.`];
+}
+function envFileApplyFailedError(command, filePath, scope, failedKey, writtenVariables, error) {
+	const writtenKeys = writtenVariables.map((variable) => variable.key);
+	const cause = error instanceof CliError ? error.summary : error instanceof Error ? error.message : "Unknown error.";
+	return new CliError({
+		code: "ENV_FILE_APPLY_FAILED",
+		domain: "app",
+		summary: `Failed to ${command} "${failedKey}" from "${filePath}"`,
+		why: writtenKeys.length === 0 ? `No variables were written before ${failedKey} failed. Cause: ${cause}` : `Written keys before failure: ${formatKeyList(writtenKeys)}. Cause: ${cause}`,
+		fix: "Inspect the target scope, then retry the remaining keys once the API issue is resolved.",
+		exitCode: 1,
+		nextSteps: [`prisma-cli project env list ${formatScopeFlag(scope)}`, retryStepForApplyFailure(command, filePath, scope, writtenKeys)],
+		meta: {
+			file: filePath,
+			failedKey,
+			writtenKeys
+		}
+	});
+}
+function retryStepForApplyFailure(command, filePath, scope, writtenKeys) {
+	if (command === "update") return `prisma-cli project env update --file ${filePath} ${formatScopeFlag(scope)}`;
+	if (writtenKeys.length === 0) return `prisma-cli project env add --file ${filePath} ${formatScopeFlag(scope)}`;
+	return `prisma-cli project env add --file <remaining.env> ${formatScopeFlag(scope)}`;
+}
+function splitFileNextSteps(filePath, scope, options) {
+	const scopeFlag = formatScopeFlag(scope);
+	const existingFile = `${filePath}.existing`;
+	const newFile = `${filePath}.new`;
+	if (options.first === "update-existing") return [
+		`# existing keys: ${formatKeyList(options.existingKeys)}`,
+		`prisma-cli project env update --file ${existingFile} ${scopeFlag}`,
+		"# new keys only",
+		`prisma-cli project env add --file ${newFile} ${scopeFlag}`
+	];
+	return [
+		`# missing keys: ${formatKeyList(options.missingKeys)}`,
+		`prisma-cli project env add --file ${newFile} ${scopeFlag}`,
+		"# existing keys only",
+		`prisma-cli project env update --file ${existingFile} ${scopeFlag}`
+	];
+}
+function formatKeyList(keys) {
+	return keys.map((key) => `"${key}"`).join(", ");
+}
+function formatScopeFlag(scope) {
+	if (scope.kind === "role") return `--role ${scope.role}`;
+	return `--branch ${scope.branchName}`;
+}
+//#endregion
+export { runEnvAddFile, runEnvUpdateFile };

package/dist/controllers/app-env.js

@@ -5,29 +5,34 @@ 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
 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"
@@ -40,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: {
@@ -64,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: {
@@ -102,6 +109,32 @@ 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 explicit = resolveEnvScope(flags, {
 		requireExplicit: false,
@@ -410,18 +443,6 @@ 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
-	});
-	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) {
 	return materializeEffectiveRows(await collectEnvironmentVariables(client, projectId, signal, {
 		className: resolved.apiTarget.class,
@@ -461,9 +482,6 @@ function rowMatchesScope(row, resolved) {
 	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();
@@ -471,40 +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";
-	if (scope.kind === "overview") return "overview";
-	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/lib/app/env-config.js

@@ -64,4 +64,4 @@ function formatScopeLabel(scope) {
 	return `branch:${scope.branchName}`;
 }
 //#endregion
-export { formatScopeLabel, parseKeyValuePositional, resolveEnvScope };
+export { formatScopeLabel, parseKeyValuePositional, resolveEnvScope, validateKey };

package/dist/lib/app/env-file.js

@@ -0,0 +1,82 @@
+import { usageError } from "../../shell/errors.js";
+import { validateKey } from "./env-config.js";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { parse } from "dotenv";
+//#region src/lib/app/env-file.ts
+const ASSIGNMENT_KEY_PATTERN = /^\s*(?:export\s+)?([^#=\s]+)\s*=/;
+async function readEnvFileAssignments(cwd, filePath, command) {
+	const resolvedPath = path.resolve(cwd, filePath);
+	let contents;
+	try {
+		contents = await readFile(resolvedPath, "utf8");
+	} catch (error) {
+		throw usageError(`Failed to read env file "${filePath}"`, error instanceof Error ? error.message : "The file could not be read.", "Pass a readable dotenv file path.", [`prisma-cli project env ${command} --file .env --role preview`], "app");
+	}
+	return parseEnvFileContents(contents, filePath, command);
+}
+function parseEnvFileContents(contents, filePath, command) {
+	const parsedKeys = extractParsedKeys(contents);
+	if (parsedKeys.length === 0) throw usageError(`No environment variables found in "${filePath}"`, "The file does not contain any KEY=VALUE assignments.", "Pass a dotenv file with at least one non-empty variable.", [], "app");
+	const seen = /* @__PURE__ */ new Map();
+	for (const entry of parsedKeys) {
+		validateEnvFileKey(entry.key, entry.line, filePath, command);
+		const firstLine = seen.get(entry.key);
+		if (firstLine !== void 0) throw usageError(`Duplicate environment variable "${entry.key}" in "${filePath}"`, `Lines ${firstLine} and ${entry.line} both define ${entry.key}.`, "Keep one assignment for each key before importing the file.", [], "app");
+		seen.set(entry.key, entry.line);
+	}
+	const parsedValues = parse(contents);
+	return parsedKeys.map(({ key }) => {
+		const value = parsedValues[key];
+		if (typeof value !== "string" || value.length === 0) {
+			const line = seen.get(key);
+			throw usageError(`Environment variable "${key}" in "${filePath}" has an empty value`, line === void 0 ? `${key} has an empty value.` : `Line ${line} defines ${key} with an empty value.`, "Pass a non-empty value, or omit the key from the file.", [], "app");
+		}
+		return {
+			key,
+			value
+		};
+	});
+}
+function extractParsedKeys(contents) {
+	const keys = [];
+	let multilineQuote = null;
+	const lines = contents.split(/\n/);
+	for (const [index, line] of lines.entries()) {
+		const lineNumber = index + 1;
+		if (multilineQuote !== null) {
+			if (hasClosingQuote(line, multilineQuote, 0)) multilineQuote = null;
+			continue;
+		}
+		const match = ASSIGNMENT_KEY_PATTERN.exec(line);
+		if (!match) continue;
+		const key = match[1];
+		keys.push({
+			key,
+			line: lineNumber
+		});
+		const valueStart = line.slice(match[0].length).trimStart();
+		const openingQuote = valueStart[0];
+		if ((openingQuote === "\"" || openingQuote === "'" || openingQuote === "`") && !hasClosingQuote(valueStart, openingQuote, 1)) multilineQuote = openingQuote;
+	}
+	return keys;
+}
+function validateEnvFileKey(key, line, filePath, command) {
+	try {
+		validateKey(key, command);
+	} catch (error) {
+		const reason = error instanceof Error && error.message.length > 0 ? error.message : "Invalid environment variable key.";
+		throw usageError(`Invalid environment variable "${key}" in "${filePath}"`, `Line ${line}: ${reason}`, "Use a valid env-var key and retry the import.", [], "app");
+	}
+}
+function hasClosingQuote(value, quote, startIndex) {
+	for (let index = startIndex; index < value.length; index += 1) if (value[index] === quote && !isEscaped(value, index)) return true;
+	return false;
+}
+function isEscaped(value, index) {
+	let backslashes = 0;
+	for (let cursor = index - 1; cursor >= 0 && value[cursor] === "\\"; cursor -= 1) backslashes += 1;
+	return backslashes % 2 === 1;
+}
+//#endregion
+export { readEnvFileAssignments };

package/dist/lib/project/resolution.js

@@ -5,8 +5,12 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 //#region src/lib/project/resolution.ts
 async function resolveProjectTarget(options) {
+	const localPin = await readImplicitLocalPin(options, { allowEnvProjectId: true });
 	const projects = await options.listProjects();
-	const target = await resolveBoundProjectTarget(options, projects, { allowEnvProjectId: true });
+	const target = await resolveBoundProjectTarget(options, projects, {
+		allowEnvProjectId: true,
+		localPin
+	});
 	if (target) return target;
 	throw await projectSetupRequiredError({
 		cwd: options.context.runtime.cwd,
@@ -16,8 +20,12 @@ async function resolveProjectTarget(options) {
 	});
 }
 async function inspectProjectBinding(options) {
+	const localPin = await readImplicitLocalPin(options, { allowEnvProjectId: false });
 	const projects = await options.listProjects();
-	const target = await resolveBoundProjectTarget(options, projects, { allowEnvProjectId: false });
+	const target = await resolveBoundProjectTarget(options, projects, {
+		allowEnvProjectId: false,
+		localPin
+	});
 	if (target) return target;
 	return {
 		workspace: options.workspace,
@@ -73,6 +81,28 @@ function localStateStaleError() {
 		nextSteps: ["prisma-cli project list", "prisma-cli project link <id-or-name>"]
 	});
 }
+function localProjectWorkspaceMismatchError(options) {
+	return new CliError({
+		code: "LOCAL_PROJECT_WORKSPACE_MISMATCH",
+		domain: "project",
+		summary: "Project link uses another workspace",
+		why: `${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} links this directory to project ${options.pinnedProjectId} in workspace ${options.pinnedWorkspaceId}, but your current CLI session is workspace "${options.activeWorkspace.name}" (${options.activeWorkspace.id}).`,
+		fix: "Sign in to the linked workspace, or relink this directory to a project in the current workspace.",
+		meta: {
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH,
+			pinnedWorkspaceId: options.pinnedWorkspaceId,
+			pinnedProjectId: options.pinnedProjectId,
+			activeWorkspaceId: options.activeWorkspace.id,
+			activeWorkspaceName: options.activeWorkspace.name
+		},
+		exitCode: 1,
+		nextSteps: [
+			"prisma-cli auth login",
+			"prisma-cli project list",
+			"prisma-cli project link <id-or-name>"
+		]
+	});
+}
 async function buildProjectSetupSuggestion(options) {
 	const suggestedName = await inferTargetName(options.cwd, options.signal);
 	const candidates = sortProjects(options.projects.filter((project) => projectMatchesSuggestedName(project, suggestedName.name))).map(toProjectSummary);
@@ -192,10 +222,15 @@ async function resolveBoundProjectTarget(options, projects, settings) {
 			targetNameSource: "env"
 		});
 	}
-	const localPin = await readLocalResolutionPin(options.context.runtime.cwd, options.context.runtime.signal);
+	const localPin = settings.localPin;
+	if (!localPin) return null;
 	if (localPin.kind === "invalid") throw localStateStaleError();
 	if (localPin.kind === "present") {
-		if (localPin.pin.workspaceId !== options.workspace.id) throw localStateStaleError();
+		if (localPin.pin.workspaceId !== options.workspace.id) throw localProjectWorkspaceMismatchError({
+			pinnedWorkspaceId: localPin.pin.workspaceId,
+			pinnedProjectId: localPin.pin.projectId,
+			activeWorkspace: options.workspace
+		});
 		const project = projects.find((candidate) => candidate.id === localPin.pin.projectId);
 		if (!project) throw localStateStaleError();
 		return resolvedTarget(options.workspace, project, "local-pin", {
@@ -210,6 +245,16 @@ async function resolveBoundProjectTarget(options, projects, settings) {
 	});
 	return null;
 }
+async function readImplicitLocalPin(options, settings) {
+	if (options.explicitProject || settings.allowEnvProjectId && options.envProjectId) return null;
+	const localPin = await readLocalResolutionPin(options.context.runtime.cwd, options.context.runtime.signal);
+	if (localPin.kind === "present" && localPin.pin.workspaceId !== options.workspace.id) throw localProjectWorkspaceMismatchError({
+		pinnedWorkspaceId: localPin.pin.workspaceId,
+		pinnedProjectId: localPin.pin.projectId,
+		activeWorkspace: options.workspace
+	});
+	return localPin;
+}
 function resolvedTarget(workspace, project, projectSource, resolutionDetails) {
 	return {
 		workspace,

package/dist/presenters/app-env.js

@@ -15,6 +15,21 @@ function listTargetLabel(result) {
 	return scopeLabel(result.scope);
 }
 function renderEnvAdd(context, descriptor, result) {
+	if (result.variables !== void 0) return renderList({
+		title: "Setting new environment variables from file.",
+		descriptor,
+		parentContext: {
+			key: "target",
+			value: `${scopeLabel(result.scope)} from ${result.file.path}`
+		},
+		items: result.variables.map((variable) => ({
+			noun: "variable",
+			label: `${variable.key} (${variable.source})`,
+			id: variable.id,
+			status: variable.isManagedBySystem ? "default" : null
+		})),
+		emptyMessage: "No environment variables imported."
+	}, context.ui);
 	return renderShow({
 		title: "Setting a new environment variable.",
 		descriptor,
@@ -48,6 +63,21 @@ function serializeEnvAdd(result) {
 	return result;
 }
 function renderEnvUpdate(context, descriptor, result) {
+	if (result.variables !== void 0) return renderList({
+		title: "Replacing environment variable values from file.",
+		descriptor,
+		parentContext: {
+			key: "target",
+			value: `${scopeLabel(result.scope)} from ${result.file.path}`
+		},
+		items: result.variables.map((variable) => ({
+			noun: "variable",
+			label: `${variable.key} (${variable.source})`,
+			id: variable.id,
+			status: variable.isManagedBySystem ? "default" : null
+		})),
+		emptyMessage: "No environment variables updated."
+	}, context.ui);
 	return renderShow({
 		title: "Replacing the environment variable's value.",
 		descriptor,

package/dist/presenters/project.js

@@ -1,25 +1,24 @@
 import { padDisplay, renderNextSteps, renderSummaryLine } from "../shell/ui.js";
 import { formatDescriptorLabel } from "../shell/command-meta.js";
 import { formatCommandArgument } from "../shell/command-arguments.js";
-import { renderList, renderMutate, renderShow, serializeList } from "../output/patterns.js";
+import { renderMutate, renderShow, serializeList } from "../output/patterns.js";
 import path from "node:path";
+import stringWidth from "string-width";
 //#region src/presenters/project.ts
 function renderProjectList(context, descriptor, result) {
-	const lines = renderList({
-		title: "Listing projects for the authenticated workspace.",
-		descriptor,
-		parentContext: {
-			key: "workspace",
-			value: result.workspace.name
-		},
-		items: result.projects.map((project) => ({
-			noun: "project",
-			label: project.name,
-			id: project.id,
-			status: null
-		})),
-		emptyMessage: "No projects found."
-	}, context.ui);
+	const ui = context.ui;
+	const rail = ui.dim("│");
+	const lines = [`${ui.strong(formatDescriptorLabel(descriptor))} ${ui.dim("→")} ${ui.dim("Listing projects for the authenticated workspace.")}`, ""];
+	lines.push(`${rail}  ${ui.accent("workspace:")}  ${result.workspace.name}`);
+	if (result.projects.length === 0) {
+		lines.push(`${rail}  ${ui.dim("No projects found.")}`);
+		if (result.localBinding?.status === "not-linked" || result.localBinding?.status === "invalid") lines.push(...renderNextSteps(["Link an existing Project you choose: prisma-cli project link <id-or-name>", "Create a new Project: prisma-cli project create <name>"]));
+		return lines;
+	}
+	const nameWidth = Math.max(4, ...result.projects.map((project) => stringWidth(project.name)));
+	lines.push(rail);
+	lines.push(`${rail}  ${ui.accent(padDisplay("name", nameWidth))}  ${ui.accent("id")}`);
+	for (const project of result.projects) lines.push(`${rail}  ${padDisplay(project.name, nameWidth)}  ${project.id}`);
 	if (result.localBinding?.status === "not-linked" || result.localBinding?.status === "invalid") lines.push(...renderNextSteps(["Link an existing Project you choose: prisma-cli project link <id-or-name>", "Create a new Project: prisma-cli project create <name>"]));
 	return lines;
 }

package/dist/shell/command-meta.js

@@ -363,6 +363,7 @@ const DESCRIPTORS = [
 		examples: [
 			"prisma-cli project env list",
 			"prisma-cli project env add STRIPE_KEY=sk_test_xxx --role production",
+			"prisma-cli project env add --file .env --role preview",
 			"prisma-cli project env add DATABASE_URL=postgresql://branch --branch feature/foo",
 			"prisma-cli project env remove STRIPE_KEY --role preview"
 		]
@@ -379,7 +380,9 @@ const DESCRIPTORS = [
 		examples: [
 			"prisma-cli project env add STRIPE_KEY=sk_test_xxx --role production",
 			"prisma-cli project env add STRIPE_KEY=sk_test_xxx --role preview",
+			"prisma-cli project env add --file .env --role preview",
 			"prisma-cli project env add DATABASE_URL=postgresql://branch --branch feature/foo",
+			"prisma-cli project env add --file .env.local --branch feature/foo",
 			"API_URL=https://api.example prisma-cli project env add API_URL --project proj_123 --role preview"
 		]
 	},
@@ -395,6 +398,7 @@ const DESCRIPTORS = [
 		examples: [
 			"prisma-cli project env update STRIPE_KEY=sk_new_xxx --role production",
 			"prisma-cli project env update STRIPE_KEY=sk_new_xxx --role preview",
+			"prisma-cli project env update --file .env --role production",
 			"prisma-cli project env update DATABASE_URL=postgresql://branch --branch feature/foo"
 		]
 	},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-dev.61.1",
+  "version": "3.0.0-dev.63.1",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {
@@ -42,6 +42,7 @@
     "c12": "4.0.0-beta.5",
     "colorette": "^2.0.20",
     "commander": "^14.0.3",
+    "dotenv": "^17.4.2",
     "magicast": "^0.5.3",
     "open": "^11.0.0",
     "string-width": "^8.2.1",