@prisma/cli 3.0.0-dev.97.1 → 8.0.0-rc.1

package/dist/commands/database/index.js

@@ -2,8 +2,8 @@ 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 { runDatabaseBackupList, runDatabaseConnectionCreate, runDatabaseConnectionList, runDatabaseConnectionRemove, runDatabaseConnectionRotate, runDatabaseCreate, runDatabaseList, runDatabaseRemove, runDatabaseRestore, runDatabaseShow, runDatabaseUsage } from "../../controllers/database.js";
+import { renderDatabaseBackupList, renderDatabaseConnectionCreate, renderDatabaseConnectionCreateStdout, renderDatabaseConnectionList, renderDatabaseConnectionRemove, renderDatabaseConnectionRotate, renderDatabaseConnectionRotateStdout, renderDatabaseCreate, renderDatabaseCreateStdout, renderDatabaseList, renderDatabaseRemove, renderDatabaseRestore, renderDatabaseShow, renderDatabaseUsage, serializeDatabaseBackupList, serializeDatabaseConnectionCreate, serializeDatabaseConnectionList, serializeDatabaseConnectionRemove, serializeDatabaseConnectionRotate, serializeDatabaseCreate, serializeDatabaseList, serializeDatabaseRemove, serializeDatabaseRestore, serializeDatabaseShow, serializeDatabaseUsage } from "../../presenters/database.js";
 import { Command, Option } from "commander";
 //#region src/commands/database/index.ts
 function createDatabaseCommand(runtime) {
@@ -12,7 +12,10 @@ function createDatabaseCommand(runtime) {
 	database.addCommand(createDatabaseListCommand(runtime));
 	database.addCommand(createDatabaseShowCommand(runtime));
 	database.addCommand(createDatabaseCreateCommand(runtime));
+	database.addCommand(createDatabaseUsageCommand(runtime));
+	database.addCommand(createDatabaseRestoreCommand(runtime));
 	database.addCommand(createDatabaseRemoveCommand(runtime));
+	database.addCommand(createDatabaseBackupCommand(runtime));
 	database.addCommand(createDatabaseConnectionCommand(runtime));
 	return database;
 }
@@ -75,6 +78,78 @@ function createDatabaseCreateCommand(runtime) {
 	});
 	return command;
 }
+function createDatabaseUsageCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("usage"), runtime), "database.usage");
+	command.argument("<database>", "Database id or name").addOption(new Option("--from <iso-date>", "Start of the usage period")).addOption(new Option("--to <iso-date>", "End of the usage period"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const from = options.from;
+		const to = options.to;
+		await runCommand(runtime, "database.usage", options, (context) => runDatabaseUsage(context, databaseRef, {
+			projectRef,
+			branchName,
+			from,
+			to
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseUsage(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseUsage(result)
+		});
+	});
+	return command;
+}
+function createDatabaseRestoreCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("restore"), runtime), "database.restore");
+	command.argument("<database>", "Target database id or name").addOption(new Option("--backup <backup-id>", "Backup to restore from")).addOption(new Option("--source-database <database>", "Database the backup belongs to (defaults to the target)")).addOption(new Option("--confirm <database-id>", "Exact target database id required to restore"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const backupId = options.backup;
+		const sourceDatabaseRef = options.sourceDatabase;
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.restore", options, (context) => runDatabaseRestore(context, databaseRef, {
+			projectRef,
+			branchName,
+			backupId,
+			sourceDatabaseRef,
+			confirm
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseRestore(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseRestore(result)
+		});
+	});
+	return command;
+}
+function createDatabaseBackupCommand(runtime) {
+	const backup = attachCommandDescriptor(configureRuntimeCommand(new Command("backup"), runtime), "database.backup");
+	addCompactGlobalFlags(backup);
+	backup.addCommand(createDatabaseBackupListCommand(runtime));
+	return backup;
+}
+function createDatabaseBackupListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.backup.list");
+	command.argument("<database>", "Database id or name").addOption(new Option("--limit <n>", "Maximum number of backups to return"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const limit = options.limit;
+		await runCommand(runtime, "database.backup.list", options, (context) => runDatabaseBackupList(context, databaseRef, {
+			projectRef,
+			branchName,
+			limit
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseBackupList(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseBackupList(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"));
@@ -100,9 +175,24 @@ function createDatabaseConnectionCommand(runtime) {
 	addCompactGlobalFlags(connection);
 	connection.addCommand(createDatabaseConnectionListCommand(runtime));
 	connection.addCommand(createDatabaseConnectionCreateCommand(runtime));
+	connection.addCommand(createDatabaseConnectionRotateCommand(runtime));
 	connection.addCommand(createDatabaseConnectionRemoveCommand(runtime));
 	return connection;
 }
+function createDatabaseConnectionRotateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("rotate"), runtime), "database.connection.rotate");
+	command.argument("<connection>", "Connection id").addOption(new Option("--confirm <connection-id>", "Exact connection id required to rotate"));
+	addGlobalFlags(command);
+	command.action(async (connectionRef, options) => {
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.connection.rotate", options, (context) => runDatabaseConnectionRotate(context, connectionRef, { confirm }), {
+			renderStdout: (context, descriptor, result) => renderDatabaseConnectionRotateStdout(context, descriptor, result),
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionRotate(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionRotate(result)
+		});
+	});
+	return command;
+}
 function createDatabaseConnectionListCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.connection.list");
 	command.argument("<database>", "Database id or name");

package/dist/commands/feedback/index.js

@@ -0,0 +1,20 @@
+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 { runFeedback } from "../../controllers/feedback.js";
+import { renderFeedbackSuccess } from "../../presenters/feedback.js";
+import { Command, Option } from "commander";
+//#region src/commands/feedback/index.ts
+function createFeedbackCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("feedback"), runtime), "feedback");
+	command.argument("<message>", "Feedback text (up to 4000 characters)").addOption(new Option("--email <address>", "Contact email if you want a reply; feedback is anonymous without it"));
+	addGlobalFlags(command);
+	command.action(async (message, options) => {
+		const flags = options;
+		await runCommand(runtime, "feedback", options, (context) => runFeedback(context, message, { email: flags.email }), { renderHuman: (context, descriptor, result) => renderFeedbackSuccess(context, descriptor, result) });
+	});
+	return command;
+}
+//#endregion
+export { createFeedbackCommand };

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

@@ -0,0 +1,33 @@
+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 { runInit } from "../../controllers/init.js";
+import { renderInit, serializeInit } from "../../presenters/init.js";
+import { Command, Option } from "commander";
+//#region src/commands/init/index.ts
+function createInitCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("init"), runtime), "init");
+	command.addOption(new Option("--framework <framework>", "Framework override; detected when omitted")).addOption(new Option("--entry <path>", "Source entrypoint for entrypoint frameworks (Bun, Hono)")).addOption(new Option("--http-port <port>", "HTTP port the app listens on")).addOption(new Option("--region <region>", "Region used when deploy creates the app")).addOption(new Option("--name <app-name>", "App name")).addOption(new Option("--link", "Link this directory to a Project")).addOption(new Option("--no-link", "Skip the Project link step")).addOption(new Option("--project <id-or-name>", "Project to link this directory to")).addOption(new Option("--install", "Install @prisma/compute-sdk for config types")).addOption(new Option("--no-install", "Skip the types install step")).addOption(new Option("--format <ts|json>", "Config file format: ts (default) writes prisma.compute.ts, json writes dependency-free prisma.compute.json; --format ts converts an existing prisma.compute.json"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const flags = options;
+		await runCommand(runtime, "init", options, (context) => runInit(context, {
+			framework: flags.framework,
+			entry: flags.entry,
+			httpPort: flags.httpPort,
+			region: flags.region,
+			name: flags.name,
+			link: flags.link,
+			project: flags.project,
+			install: flags.install,
+			format: flags.format
+		}), {
+			renderHuman: (context, descriptor, result) => renderInit(context, descriptor, result),
+			renderJson: (result) => serializeInit(result)
+		});
+	});
+	return command;
+}
+//#endregion
+export { createInitCommand };

package/dist/commands/project/index.js

@@ -1,11 +1,11 @@
 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 { renderProjectList, renderProjectSetup, renderProjectShow, serializeProjectList, serializeProjectSetup, serializeProjectShow } from "../../presenters/project.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 } from "commander";
+import { Command, Option } from "commander";
 //#region src/commands/project/index.ts
 function createProjectCommand(runtime) {
 	const project = attachCommandDescriptor(configureRuntimeCommand(new Command("project"), runtime), "project");
@@ -14,15 +14,64 @@ function createProjectCommand(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");
+	command.argument("<name>", "Project name").addOption(new Option("--region <region>", "Prisma Compute region id"));
 	addGlobalFlags(command);
 	command.action(async (name, options) => {
-		await runCommand(runtime, "project.create", options, (context) => runProjectCreate(context, String(name)), {
+		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)
 		});

package/dist/controllers/agent-setup.js

@@ -0,0 +1,52 @@
+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

@@ -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 "../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,11 +1,12 @@
-import { CliError, authRequiredError } from "../shell/errors.js";
+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
+			key,
+			...resolved.apiTarget.branchId !== null ? { branchId: resolved.apiTarget.branchId } : {}
 		} },
 		signal
 	});

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

@@ -1,4 +1,4 @@
-import { CliError } from "../shell/errors.js";
+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

package/dist/controllers/app-env.js

@@ -1,9 +1,9 @@
-import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../shell/errors.js";
+import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../errors.js";
+import { authenticatedManagementApiClient } from "../auth/guard.js";
 import { formatScopeLabel, parseKeyValuePositional, resolveEnvScope } from "../lib/app/env-config.js";
 import { readEnvFileAssignments } from "../lib/app/env-file.js";
-import { projectResolutionErrorToCliError, resolveProjectTarget } from "../lib/project/resolution.js";
-import { requireComputeAuth } from "../lib/auth/guard.js";
 import { readLocalGitBranch } from "../lib/git/local-branch.js";
+import { projectResolutionErrorToCliError, resolveProjectTarget } from "../lib/project/resolution.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
 import { listRealWorkspaceProjects } from "./project.js";
 import { apiCallError, findVariableByNaturalKey, toMetadata } from "./app-env-api.js";
@@ -202,7 +202,7 @@ async function runEnvRemove(context, key, flags) {
 }
 async function requireClientAndProject(context, explicitProject, commandName) {
 	const authState = await requireAuthenticatedAuthState(context);
-	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+	const client = await authenticatedManagementApiClient(context.runtime.env, context.runtime.signal);
 	if (!client) throw authRequiredError(["prisma-cli auth login"]);
 	const workspace = authState.workspace;
 	if (!workspace) throw workspaceRequiredError();
@@ -210,7 +210,7 @@ async function requireClientAndProject(context, explicitProject, commandName) {
 		context,
 		workspace,
 		explicitProject,
-		listProjects: () => listRealWorkspaceProjects(client, workspace, context.runtime.signal),
+		listProjects: () => listRealWorkspaceProjects(client, context.runtime.signal),
 		commandName
 	});
 	if (targetResult.isErr()) throw projectResolutionErrorToCliError(targetResult.error);