@prisma/cli 8.0.0-rc.1 → 8.0.0-rc.10-dev.80

package/dist/commands/project/index.js

@@ -1,118 +0,0 @@
-import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
-import { configureRuntimeCommand } from "../../shell/runtime.js";
-import { runCommand } from "../../shell/command-runner.js";
-import { runProjectCreate, runProjectLink, runProjectList, runProjectRemove, runProjectRename, runProjectShow, runProjectTransfer } from "../../controllers/project.js";
-import { renderProjectList, renderProjectRemove, renderProjectRename, renderProjectSetup, renderProjectShow, renderProjectTransfer, serializeProjectList, serializeProjectRemove, serializeProjectRename, serializeProjectSetup, serializeProjectShow, serializeProjectTransfer } from "../../presenters/project.js";
-import { createEnvCommand } from "../env.js";
-import { Command, Option } from "commander";
-//#region src/commands/project/index.ts
-function createProjectCommand(runtime) {
-	const project = attachCommandDescriptor(configureRuntimeCommand(new Command("project"), runtime), "project");
-	addCompactGlobalFlags(project);
-	project.addCommand(createProjectListCommand(runtime));
-	project.addCommand(createProjectShowCommand(runtime));
-	project.addCommand(createProjectCreateCommand(runtime));
-	project.addCommand(createProjectLinkCommand(runtime));
-	project.addCommand(createProjectRenameCommand(runtime));
-	project.addCommand(createProjectRemoveCommand(runtime));
-	project.addCommand(createProjectTransferCommand(runtime));
-	project.addCommand(createEnvCommand(runtime));
-	return project;
-}
-function createProjectRenameCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("rename"), runtime), "project.rename");
-	command.argument("<name>", "New project name").addOption(new Option("--project <id-or-name>", "Project id or name"));
-	addGlobalFlags(command);
-	command.action(async (name, options) => {
-		const projectRef = options.project;
-		await runCommand(runtime, "project.rename", options, (context) => runProjectRename(context, name, { project: projectRef }), {
-			renderHuman: (context, descriptor, result) => renderProjectRename(context, descriptor, result),
-			renderJson: (result) => serializeProjectRename(result)
-		});
-	});
-	return command;
-}
-function createProjectRemoveCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "project.remove");
-	command.argument("<project>", "Project id or name").addOption(new Option("--confirm <project-id>", "Exact project id required to remove"));
-	addGlobalFlags(command);
-	command.action(async (projectRef, options) => {
-		const confirm = options.confirm;
-		await runCommand(runtime, "project.remove", options, (context) => runProjectRemove(context, projectRef, { confirm }), {
-			renderHuman: (context, descriptor, result) => renderProjectRemove(context, descriptor, result),
-			renderJson: (result) => serializeProjectRemove(result)
-		});
-	});
-	return command;
-}
-function createProjectTransferCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("transfer"), runtime), "project.transfer");
-	command.argument("<project>", "Project id or name").addOption(new Option("--to-workspace <id-or-name>", "Locally authenticated workspace to receive the project")).addOption(new Option("--recipient-token <token>", "Access token for the receiving workspace")).addOption(new Option("--confirm <project-id>", "Exact project id required to transfer"));
-	addGlobalFlags(command);
-	command.action(async (projectRef, options) => {
-		const toWorkspace = options.toWorkspace;
-		const recipientToken = options.recipientToken;
-		const confirm = options.confirm;
-		await runCommand(runtime, "project.transfer", options, (context) => runProjectTransfer(context, projectRef, {
-			toWorkspace,
-			recipientToken,
-			confirm
-		}), {
-			renderHuman: (context, descriptor, result) => renderProjectTransfer(context, descriptor, result),
-			renderJson: (result) => serializeProjectTransfer(result)
-		});
-	});
-	return command;
-}
-function createProjectCreateCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "project.create");
-	command.argument("<name>", "Project name").addOption(new Option("--region <region>", "Prisma Compute region id"));
-	addGlobalFlags(command);
-	command.action(async (name, options) => {
-		const region = options.region;
-		await runCommand(runtime, "project.create", options, (context) => runProjectCreate(context, String(name), { region }), {
-			renderHuman: (context, descriptor, result) => renderProjectSetup(context, descriptor, result),
-			renderJson: (result) => serializeProjectSetup(result)
-		});
-	});
-	return command;
-}
-function createProjectLinkCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("link"), runtime), "project.link");
-	command.argument("[id-or-name]", "Project id or name");
-	addGlobalFlags(command);
-	command.action(async (projectRef, options) => {
-		await runCommand(runtime, "project.link", options, (context) => runProjectLink(context, typeof projectRef === "string" ? projectRef : void 0), {
-			renderHuman: (context, descriptor, result) => renderProjectSetup(context, descriptor, result),
-			renderJson: (result) => serializeProjectSetup(result)
-		});
-	});
-	return command;
-}
-function createProjectListCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "project.list");
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "project.list", options, (context) => runProjectList(context), {
-			renderHuman: (context, descriptor, result) => renderProjectList(context, descriptor, result),
-			renderJson: (result) => serializeProjectList(result)
-		});
-	});
-	return command;
-}
-function createProjectShowCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "project.show");
-	command.option("--project <id-or-name>", "Project id or name");
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		const projectRef = options.project;
-		await runCommand(runtime, "project.show", options, (context) => runProjectShow(context, projectRef), {
-			renderHuman: (context, descriptor, result) => renderProjectShow(context, descriptor, result),
-			renderJson: (result) => serializeProjectShow(result)
-		});
-	});
-	return command;
-}
-//#endregion
-export { createProjectCommand };

package/dist/commands/version/index.js

@@ -1,18 +0,0 @@
-import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { addGlobalFlags } from "../../shell/global-flags.js";
-import { configureRuntimeCommand } from "../../shell/runtime.js";
-import { runCommand } from "../../shell/command-runner.js";
-import { runVersion } from "../../controllers/version.js";
-import { renderVersionSuccess } from "../../presenters/version.js";
-import { Command } from "commander";
-//#region src/commands/version/index.ts
-function createVersionCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("version"), runtime), "version");
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "version", options, (context) => runVersion(context), { renderHuman: (context, descriptor, result) => renderVersionSuccess(context, descriptor, result) });
-	});
-	return command;
-}
-//#endregion
-export { createVersionCommand };

package/dist/controllers/agent-setup.js

@@ -1,52 +0,0 @@
-import { resolvePrismaCliPackageCommand } from "../lib/agent/cli-command.js";
-import { PRISMA_AGENT_INSTALL_ARGS, PRISMA_COMPUTE_AGENT_SKILL } from "../lib/agent/constants.js";
-import { readPrismaAgentSetupStatus, shouldOfferPrismaAgentSetup } from "../lib/agent/setup-status.js";
-import { runAgentInstall } from "./agent.js";
-import { renderSummaryLine } from "../shell/ui.js";
-import { canPrompt } from "../shell/runtime.js";
-import { confirmPrompt } from "../shell/prompt.js";
-//#region src/controllers/agent-setup.ts
-/**
-* One-time interactive offer to install the Prisma Compute skill for the
-* project. Shared by the commands that establish a project setup (init,
-* deploy); the answer is remembered, so whichever command runs first asks.
-* Returns warnings; a failed install must not fail the calling command.
-*/
-async function maybePromptForAgentSetup(context, projectDir) {
-	if (!canPrompt(context) || context.flags.yes || context.flags.quiet) return [];
-	if (!shouldOfferPrismaAgentSetup(await readPrismaAgentSetupStatus({
-		cwd: projectDir,
-		stateStore: context.stateStore,
-		signal: context.runtime.signal,
-		requiredSkill: "prisma-compute"
-	}))) return [];
-	if (!await confirmPrompt({
-		input: context.runtime.stdin,
-		output: context.runtime.stderr,
-		signal: context.runtime.signal,
-		message: "Install the Prisma Compute skill for this project?",
-		initialValue: true
-	})) {
-		await context.stateStore.setAgentSetupPromptDismissedAt((/* @__PURE__ */ new Date()).toISOString());
-		return [];
-	}
-	try {
-		await runAgentInstall(context, { skill: [PRISMA_COMPUTE_AGENT_SKILL] }, "install", { cwd: projectDir });
-		if (!context.flags.quiet && !context.flags.json) context.output.stderr.write(`${renderSummaryLine(context.ui, "success", "Installed the Prisma Compute skill for this project.")}\n\n`);
-		return [];
-	} catch (error) {
-		const message = error instanceof Error ? error.message : "Prisma skill install failed.";
-		if (!context.flags.quiet && !context.flags.json) context.output.stderr.write(`${renderSummaryLine(context.ui, "warning", `Skipped Prisma skill install: ${message}`)}\n\n`);
-		return [`The Prisma Compute skill was not installed. Run ${await resolvePrismaCliPackageCommand({
-			cwd: projectDir,
-			signal: context.runtime.signal,
-			args: [
-				...PRISMA_AGENT_INSTALL_ARGS,
-				"--skill",
-				PRISMA_COMPUTE_AGENT_SKILL
-			]
-		})} to try again.`];
-	}
-}
-//#endregion
-export { maybePromptForAgentSetup };

package/dist/controllers/agent.js

@@ -1,228 +0,0 @@
-import { resolveSkillsPackageRunner } from "../lib/agent/package-manager.js";
-import { resolvePrismaCliPackageCommand } from "../lib/agent/cli-command.js";
-import { DEFAULT_PRISMA_AGENT_SKILLS, DEFAULT_PRISMA_AGENT_TARGETS, PRISMA_AGENT_INSTALL_ARGS, PRISMA_AGENT_STATUS_ARGS, PRISMA_SKILLS_SOURCE, SKILLS_CLI_PACKAGE } from "../lib/agent/constants.js";
-import { readPrismaAgentSetupStatus, resolvePrismaAgentSetupCwd } from "../lib/agent/setup-status.js";
-import { formatShellCommand } from "../command-arguments.js";
-import { CliError } from "../errors.js";
-import { execa } from "execa";
-//#region src/controllers/agent.ts
-async function runAgentInstall(context, options, operation = "install", runOptions = {}) {
-	const dryRun = options.dryRun === true;
-	const cwd = await resolvePrismaAgentSetupCwd({
-		cwd: runOptions.cwd ?? context.runtime.cwd,
-		signal: context.runtime.signal
-	});
-	const skills = await installSkills(context, {
-		command: await buildSkillsInstallCommand(context, options, cwd),
-		cwd,
-		dryRun
-	});
-	const nextSteps = await resolveAgentInstallNextSteps(context, {
-		cwd,
-		dryRun,
-		global: options.global === true
-	});
-	return {
-		command: `agent.${operation}`,
-		result: {
-			operation,
-			skills
-		},
-		warnings: [],
-		nextSteps
-	};
-}
-async function resolveAgentInstallNextSteps(context, options) {
-	if (options.dryRun) return [];
-	return [`Run ${await resolvePrismaCliPackageCommand({
-		cwd: options.cwd,
-		signal: context.runtime.signal,
-		args: options.global ? [...PRISMA_AGENT_STATUS_ARGS, "--global"] : PRISMA_AGENT_STATUS_ARGS
-	})} to verify the installed Prisma skills.`];
-}
-async function runAgentStatus(context, options = {}) {
-	const statusScope = options.global ? "global" : "project";
-	const cwd = await resolvePrismaAgentSetupCwd({
-		cwd: context.runtime.cwd,
-		signal: context.runtime.signal
-	});
-	const status = await readPrismaAgentSetupStatus({
-		cwd,
-		stateStore: context.stateStore,
-		signal: context.runtime.signal
-	});
-	const installCommand = await resolvePrismaCliPackageCommand({
-		cwd,
-		signal: context.runtime.signal,
-		args: options.global ? [...PRISMA_AGENT_INSTALL_ARGS, "--global"] : PRISMA_AGENT_INSTALL_ARGS
-	});
-	const skillsList = await listInstalledPrismaSkills(context, cwd, statusScope);
-	const skillsInstalled = skillsList.status === "ok" ? skillsList.skills.length > 0 : statusScope === "project" && status.skillsInstalled;
-	const warnings = skillsList.status === "ok" ? [] : [statusScope === "project" ? `Could not read installed skills with ${formatShellCommand(skillsList.command)}: ${skillsList.message}. Falling back to ${status.skillsLockPath}.` : `Could not read globally installed skills with ${formatShellCommand(skillsList.command)}: ${skillsList.message}.`];
-	const statusSource = resolveStatusSource(skillsList, statusScope);
-	return {
-		command: "agent.status",
-		result: {
-			skills: skillsList.status === "ok" ? skillsList.skills : [],
-			skillsListCommand: skillsList.command,
-			statusScope,
-			skillsLockPath: status.skillsLockPath,
-			skillsLockInstalled: status.skillsInstalled,
-			skillsInstalled,
-			statusSource,
-			promptDismissedAt: status.promptDismissedAt
-		},
-		warnings,
-		nextSteps: skillsInstalled ? [] : [`Run ${installCommand} to install or refresh Prisma skills.`]
-	};
-}
-async function buildSkillsInstallCommand(context, options, cwd) {
-	const command = [
-		...await resolveSkillsPackageRunner({
-			cwd,
-			signal: context.runtime.signal
-		}),
-		SKILLS_CLI_PACKAGE,
-		"add",
-		PRISMA_SKILLS_SOURCE
-	];
-	const skills = options.skill && options.skill.length > 0 ? options.skill : DEFAULT_PRISMA_AGENT_SKILLS;
-	const agents = resolveTargetAgents(options);
-	for (const skill of skills) command.push("--skill", skill);
-	for (const agent of agents) command.push("--agent", agent);
-	if (options.global) command.push("--global");
-	if (options.copy || process.platform === "win32") command.push("--copy");
-	command.push("--yes");
-	return command;
-}
-function resolveTargetAgents(options) {
-	if (options.allAgents) return ["*"];
-	if (options.agent && options.agent.length > 0) return options.agent;
-	return DEFAULT_PRISMA_AGENT_TARGETS;
-}
-async function installSkills(context, options) {
-	if (options.dryRun) return {
-		status: "would-install",
-		command: options.command
-	};
-	await runChildProcess(context, options.command, options.cwd);
-	return {
-		status: "installed",
-		command: options.command
-	};
-}
-async function listInstalledPrismaSkills(context, cwd, scope) {
-	const command = [
-		...await resolveSkillsPackageRunner({
-			cwd,
-			signal: context.runtime.signal
-		}),
-		SKILLS_CLI_PACKAGE,
-		"list",
-		...scope === "global" ? ["-g"] : [],
-		"--json"
-	];
-	try {
-		const { stdout } = await runChildProcessCapture(context, command, cwd);
-		return {
-			status: "ok",
-			command,
-			skills: parseSkillsListOutput(stdout).filter((skill) => isPrismaSkillName(skill.name))
-		};
-	} catch (error) {
-		if (isAbortError(error) || context.runtime.signal.aborted) throw error;
-		return {
-			status: "failed",
-			command,
-			message: error instanceof Error ? error.message : String(error)
-		};
-	}
-}
-async function runChildProcess(context, command, cwd) {
-	const [executable, args] = splitCommand(command);
-	try {
-		await execa(executable, args, {
-			cwd,
-			env: context.runtime.env,
-			cancelSignal: context.runtime.signal,
-			stdin: "ignore"
-		});
-	} catch (error) {
-		if (isAbortError(error)) throw error;
-		throw skillsInstallFailed(command, exitCodeFromError(error), error);
-	}
-}
-async function runChildProcessCapture(context, command, cwd) {
-	const [executable, args] = splitCommand(command);
-	const result = await execa(executable, args, {
-		cwd,
-		env: context.runtime.env,
-		cancelSignal: context.runtime.signal,
-		stdin: "ignore"
-	});
-	return {
-		stdout: result.stdout ?? "",
-		stderr: result.stderr ?? ""
-	};
-}
-function splitCommand(command) {
-	const [executable, ...args] = command;
-	if (!executable) throw new Error("Cannot run an empty command.");
-	return [executable, args];
-}
-function isAbortError(error) {
-	return error instanceof Error && error.name === "AbortError" || isObject(error) && error.isCanceled === true;
-}
-function exitCodeFromError(error) {
-	if (!isObject(error) || typeof error.exitCode !== "number") return null;
-	return error.exitCode;
-}
-function isObject(value) {
-	return typeof value === "object" && value !== null;
-}
-function resolveStatusSource(skillsList, statusScope) {
-	if (skillsList.status === "ok") return "skills-cli";
-	return statusScope === "project" ? "skills-lock" : "unavailable";
-}
-function parseSkillsListOutput(output) {
-	const parsed = JSON.parse(output);
-	if (!Array.isArray(parsed)) throw new Error("skills list did not return a JSON array");
-	return parsed.flatMap((item) => {
-		const skill = parseInstalledSkill(item);
-		return skill ? [skill] : [];
-	});
-}
-function parseInstalledSkill(value) {
-	if (typeof value !== "object" || value === null) return null;
-	const candidate = value;
-	if (typeof candidate.name !== "string" || typeof candidate.path !== "string" || typeof candidate.scope !== "string" || !Array.isArray(candidate.agents)) return null;
-	return {
-		name: candidate.name,
-		path: candidate.path,
-		scope: candidate.scope,
-		agents: candidate.agents.filter((agent) => typeof agent === "string")
-	};
-}
-function isPrismaSkillName(name) {
-	return name === "prisma" || name.startsWith("prisma-");
-}
-function skillsInstallFailed(command, code, error) {
-	const commandText = formatShellCommand(command);
-	return new CliError({
-		code: "AGENT_SKILLS_INSTALL_FAILED",
-		domain: "cli",
-		summary: "Prisma skills install failed",
-		why: `The skills installer exited with code ${code ?? "unknown"}.`,
-		fix: "Run the command below to retry the installer directly.",
-		debug: formatErrorDebug(error),
-		exitCode: 1,
-		nextSteps: [commandText]
-	});
-}
-function formatErrorDebug(error) {
-	if (error instanceof Error) return error.stack ?? error.message;
-	if (error === void 0) return;
-	return String(error);
-}
-//#endregion
-export { runAgentInstall, runAgentStatus };

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

@@ -1,55 +0,0 @@
-import { CliError, authRequiredError } from "../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,
-			...resolved.apiTarget.branchId !== null ? { branchId: resolved.apiTarget.branchId } : {}
-		} },
-		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

@@ -1,181 +0,0 @@
-import { CliError } from "../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, verboseContext) {
-	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,
-			verboseContext,
-			scope: resolved.descriptor,
-			variables,
-			file: {
-				path: filePath,
-				count: variables.length
-			}
-		},
-		warnings,
-		nextSteps: []
-	};
-}
-async function runEnvUpdateFile(context, client, projectId, resolved, filePath, assignments, verboseContext) {
-	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,
-			verboseContext,
-			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 };