@prisma/cli 3.0.0-beta.2 → 3.0.0-beta.20

package/dist/commands/build/index.js

@@ -0,0 +1,29 @@
+import { attachCommandDescriptor } from "../../shell/command-meta.js";
+import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
+import { configureRuntimeCommand } from "../../shell/runtime.js";
+import { runStreamingCommand } from "../../shell/command-runner.js";
+import { runBuildLogs } from "../../controllers/build.js";
+import { Command, Option } from "commander";
+//#region src/commands/build/index.ts
+function createBuildCommand(runtime) {
+	const build = attachCommandDescriptor(configureRuntimeCommand(new Command("build"), runtime), "build");
+	addCompactGlobalFlags(build);
+	build.addCommand(createLogsCommand(runtime));
+	return build;
+}
+function createLogsCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("logs"), runtime), "build.logs");
+	command.argument("<buildId>", "Build id from a git-push or Console deploy").addOption(new Option("--follow", "Keep the connection open and stream new logs as the build runs")).addOption(new Option("--cursor <cursor>", "Resume from a prior terminal cursor"));
+	addGlobalFlags(command);
+	command.action(async (buildId, options) => {
+		const follow = options.follow;
+		const cursor = options.cursor;
+		await runStreamingCommand(runtime, "build.logs", options, (context) => runBuildLogs(context, buildId, {
+			follow,
+			cursor
+		}), { emitJsonSuccessEvent: false });
+	});
+	return command;
+}
+//#endregion
+export { createBuildCommand };

package/dist/commands/database/index.js

@@ -0,0 +1,159 @@
+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 { runDatabaseConnectionCreate, runDatabaseConnectionList, runDatabaseConnectionRemove, runDatabaseCreate, runDatabaseList, runDatabaseRemove, runDatabaseShow } from "../../controllers/database.js";
+import { renderDatabaseConnectionCreate, renderDatabaseConnectionCreateStdout, renderDatabaseConnectionList, renderDatabaseConnectionRemove, renderDatabaseCreate, renderDatabaseCreateStdout, renderDatabaseList, renderDatabaseRemove, renderDatabaseShow, serializeDatabaseConnectionCreate, serializeDatabaseConnectionList, serializeDatabaseConnectionRemove, serializeDatabaseCreate, serializeDatabaseList, serializeDatabaseRemove, serializeDatabaseShow } from "../../presenters/database.js";
+import { Command, Option } from "commander";
+//#region src/commands/database/index.ts
+function createDatabaseCommand(runtime) {
+	const database = attachCommandDescriptor(configureRuntimeCommand(new Command("database"), runtime), "database");
+	addCompactGlobalFlags(database);
+	database.addCommand(createDatabaseListCommand(runtime));
+	database.addCommand(createDatabaseShowCommand(runtime));
+	database.addCommand(createDatabaseCreateCommand(runtime));
+	database.addCommand(createDatabaseRemoveCommand(runtime));
+	database.addCommand(createDatabaseConnectionCommand(runtime));
+	return database;
+}
+function addProjectAndBranchOptions(command) {
+	return command.addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--branch <git-name>", "Branch git name"));
+}
+function createDatabaseListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.list");
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		await runCommand(runtime, "database.list", options, (context) => runDatabaseList(context, {
+			projectRef,
+			branchName
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseList(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseList(result)
+		});
+	});
+	return command;
+}
+function createDatabaseShowCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "database.show");
+	command.argument("<database>", "Database id or name");
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		await runCommand(runtime, "database.show", options, (context) => runDatabaseShow(context, databaseRef, {
+			projectRef,
+			branchName
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseShow(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseShow(result)
+		});
+	});
+	return command;
+}
+function createDatabaseCreateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "database.create");
+	command.argument("<name>", "Database name").addOption(new Option("--region <region>", "Prisma Postgres region id"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (name, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const region = options.region;
+		await runCommand(runtime, "database.create", options, (context) => runDatabaseCreate(context, name, {
+			projectRef,
+			branchName,
+			region
+		}), {
+			renderStdout: (context, descriptor, result) => renderDatabaseCreateStdout(context, descriptor, result),
+			renderHuman: (context, descriptor, result) => renderDatabaseCreate(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseCreate(result)
+		});
+	});
+	return command;
+}
+function createDatabaseRemoveCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "database.remove");
+	command.argument("<database>", "Database id or name").addOption(new Option("--confirm <database-id>", "Exact database id required to remove"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.remove", options, (context) => runDatabaseRemove(context, databaseRef, {
+			projectRef,
+			branchName,
+			confirm
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseRemove(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseRemove(result)
+		});
+	});
+	return command;
+}
+function createDatabaseConnectionCommand(runtime) {
+	const connection = attachCommandDescriptor(configureRuntimeCommand(new Command("connection"), runtime), "database.connection");
+	addCompactGlobalFlags(connection);
+	connection.addCommand(createDatabaseConnectionListCommand(runtime));
+	connection.addCommand(createDatabaseConnectionCreateCommand(runtime));
+	connection.addCommand(createDatabaseConnectionRemoveCommand(runtime));
+	return connection;
+}
+function createDatabaseConnectionListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.connection.list");
+	command.argument("<database>", "Database id or name");
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		await runCommand(runtime, "database.connection.list", options, (context) => runDatabaseConnectionList(context, databaseRef, {
+			projectRef,
+			branchName
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionList(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionList(result)
+		});
+	});
+	return command;
+}
+function createDatabaseConnectionCreateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "database.connection.create");
+	command.argument("<database>", "Database id or name").addOption(new Option("--name <name>", "Connection name"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const name = options.name;
+		await runCommand(runtime, "database.connection.create", options, (context) => runDatabaseConnectionCreate(context, databaseRef, {
+			projectRef,
+			branchName,
+			name
+		}), {
+			renderStdout: (context, descriptor, result) => renderDatabaseConnectionCreateStdout(context, descriptor, result),
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionCreate(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionCreate(result)
+		});
+	});
+	return command;
+}
+function createDatabaseConnectionRemoveCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "database.connection.remove");
+	command.argument("<connection>", "Connection id").addOption(new Option("--confirm <connection-id>", "Exact connection id required to remove"));
+	addGlobalFlags(command);
+	command.action(async (connectionRef, options) => {
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.connection.remove", options, (context) => runDatabaseConnectionRemove(context, connectionRef, { confirm }), {
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionRemove(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionRemove(result)
+		});
+	});
+	return command;
+}
+//#endregion
+export { createDatabaseCommand };

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/commands/git/index.js

@@ -1,8 +1,8 @@
 import { attachCommandDescriptor } from "../../shell/command-meta.js";
 import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
-import { runGitConnect, runGitDisconnect } from "../../controllers/project.js";
 import { runCommand } from "../../shell/command-runner.js";
+import { runGitConnect, runGitDisconnect } from "../../controllers/project.js";
 import { renderGitConnect, renderGitDisconnect } from "../../presenters/project.js";
 import { Command } from "commander";
 //#region src/commands/git/index.ts

package/dist/commands/project/index.js

@@ -1,8 +1,8 @@
 import { attachCommandDescriptor } from "../../shell/command-meta.js";
 import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
-import { runProjectCreate, runProjectLink, runProjectList, runProjectShow } from "../../controllers/project.js";
 import { runCommand } from "../../shell/command-runner.js";
+import { runProjectCreate, runProjectLink, runProjectList, runProjectShow } from "../../controllers/project.js";
 import { renderProjectList, renderProjectSetup, renderProjectShow, serializeProjectList, serializeProjectSetup, serializeProjectShow } from "../../presenters/project.js";
 import { createEnvCommand } from "../env.js";
 import { Command } from "commander";

package/dist/controllers/agent.js

@@ -0,0 +1,228 @@
+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 "../shell/command-arguments.js";
+import { CliError } from "../shell/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

@@ -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 };