@prisma/cli 3.0.0-dev.114.1 → 3.0.0-dev.115.1

package/dist/adapters/mock-api.js

@@ -32,6 +32,9 @@ var MockApi = class MockApi {
 		const workspaceIds = this.data.memberships.filter((membership) => membership.userId === userId).map((membership) => membership.workspaceId);
 		return this.data.workspaces.filter((workspace) => workspaceIds.includes(workspace.id));
 	}
+	listWorkspaces() {
+		return this.data.workspaces;
+	}
 	getWorkspace(workspaceId) {
 		return this.data.workspaces.find((workspace) => workspace.id === workspaceId);
 	}
@@ -47,6 +50,36 @@ var MockApi = class MockApi {
 	getProjectForWorkspace(workspaceId, projectId) {
 		return this.listProjectsForWorkspace(workspaceId).find((project) => project.id === projectId);
 	}
+	renameProject(projectId, name) {
+		const project = this.getProject(projectId);
+		if (!project) return;
+		project.name = name;
+		return project;
+	}
+	removeProject(projectId) {
+		const project = this.getProject(projectId);
+		if (!project) return { outcome: "not-found" };
+		if (this.data.deployments.some((deployment) => deployment.projectId === projectId)) return { outcome: "blocked" };
+		const removedDatabaseIds = new Set((this.data.databases ?? []).filter((database) => database.projectId === projectId).map((database) => database.id));
+		this.data.projects = this.data.projects.filter((candidate) => candidate.id !== projectId);
+		this.data.branches = this.data.branches.filter((branch) => branch.projectId !== projectId);
+		this.data.databases = (this.data.databases ?? []).filter((database) => database.projectId !== projectId);
+		this.data.databaseConnections = (this.data.databaseConnections ?? []).filter((connection) => !removedDatabaseIds.has(connection.databaseId));
+		return {
+			outcome: "removed",
+			project
+		};
+	}
+	transferProject(projectId, targetWorkspaceId) {
+		const project = this.getProject(projectId);
+		if (!project) return { outcome: "not-found" };
+		if (!this.getWorkspace(targetWorkspaceId)) return { outcome: "workspace-not-found" };
+		project.workspaceId = targetWorkspaceId;
+		return {
+			outcome: "transferred",
+			project
+		};
+	}
 	listBranchesForProject(projectId) {
 		return this.data.branches.filter((branch) => branch.projectId === projectId);
 	}

package/dist/adapters/token-storage.js

@@ -77,6 +77,7 @@ var FileTokenStorage = class {
 		this.signal?.throwIfAborted();
 		try {
 			const credentials = await this.readCredentialsFromDisk();
+			if (this.options.pinnedWorkspaceId) return findTokensForWorkspace(credentials, this.options.pinnedWorkspaceId);
 			const context = await this.readAuthContext();
 			if (context.state.activeWorkspaceId) return findTokensForWorkspace(credentials, context.state.activeWorkspaceId);
 			const latest = findLatestValidTokens(credentials);
@@ -138,6 +139,9 @@ var FileTokenStorage = class {
 		this.signal?.throwIfAborted();
 		const credentials = await this.readCredentialsFromDisk();
 		const context = await this.ensureMigratedAuthContext(credentials);
+		return this.workspacesFromState(credentials, context);
+	}
+	workspacesFromState(credentials, context) {
 		return credentials.map((credential) => storedCredentialToTokens(credential)).filter((tokens) => tokens !== null).map((tokens) => {
 			const cached = context.state.workspaces[tokens.workspaceId];
 			const id = typeof cached?.id === "string" && cached.id.trim().length > 0 ? cached.id.trim() : tokens.workspaceId;
@@ -159,6 +163,24 @@ var FileTokenStorage = class {
 	async useWorkspace(workspaceRef) {
 		return this.withRefreshLock(() => this.useWorkspaceUnlocked(workspaceRef));
 	}
+	/**
+	* Resolve a workspace ref (id, credential workspace id, or cached name)
+	* against the locally stored sessions without changing the active
+	* workspace. Read-only counterpart of useWorkspace: it reads the auth
+	* context as-is and never runs the legacy-state migration, so it writes
+	* nothing.
+	*/
+	async resolveWorkspace(workspaceRef) {
+		const ref = workspaceRef.trim();
+		if (!ref) throw new WorkspaceSelectionError("missing");
+		this.signal?.throwIfAborted();
+		const credentials = await this.readCredentialsFromDisk();
+		const context = await this.readAuthContext();
+		const matches = this.workspacesFromState(credentials, context).filter((workspace) => workspaceMatchesRef(workspace, ref));
+		if (matches.length === 0) throw new WorkspaceSelectionError("not-found", ref);
+		if (matches.length > 1) throw new WorkspaceSelectionError("ambiguous", ref, matches);
+		return matches[0];
+	}
 	async useWorkspaceUnlocked(workspaceRef) {
 		const ref = workspaceRef.trim();
 		if (!ref) throw new WorkspaceSelectionError("missing");
@@ -327,6 +349,7 @@ var FileTokenStorage = class {
 		await this.writeAuthContext(context.state);
 	}
 	async maybeActivateWorkspaceId(workspaceId) {
+		if (this.options.pinnedWorkspaceId) return;
 		const context = await this.readAuthContext();
 		if (this.options.activateOnSetTokens === false && context.exists && context.state.activeWorkspaceId && context.state.activeWorkspaceId !== workspaceId) return;
 		context.state.activeWorkspaceId = workspaceId;

package/dist/commands/project/index.js

@@ -2,10 +2,10 @@ 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, runProjectShow } from "../../controllers/project.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,9 +14,57 @@ 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");

package/dist/controllers/project.js

@@ -1,9 +1,12 @@
+import { resolvePrismaCliPackageCommandFormatterSync } from "../lib/agent/cli-command.js";
 import { formatCommandArgument } from "../shell/command-arguments.js";
-import { CliError, authRequiredError, featureUnavailableError, usageError, workspaceRequiredError } from "../shell/errors.js";
+import { CliError, authRequiredError, featureUnavailableError, usageError, workspaceAmbiguousError, workspaceNotAuthenticatedError, workspaceRequiredError } from "../shell/errors.js";
 import { renderSummaryLine } from "../shell/ui.js";
 import { canPrompt } from "../shell/runtime.js";
+import { SERVICE_TOKEN_ENV_VAR } from "../lib/auth/client.js";
+import { WorkspaceSelectionError } from "../adapters/token-storage.js";
 import { createAppProvider } from "../lib/app/app-provider.js";
-import { readLocalResolutionPin } from "../lib/project/local-pin.js";
+import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin, writeLocalResolutionPin } from "../lib/project/local-pin.js";
 import { buildProjectSetupNextActions, inferTargetName, inspectProjectBinding, projectResolutionErrorToCliError, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
 import { bindProjectToDirectory, isValidProjectSetupName, projectCreateFailedError, projectDirectoryBindingErrorToCliError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
@@ -11,7 +14,11 @@ import { promptForProjectSetupChoice } from "../lib/project/interactive-setup.js
 import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
 import { parseGitHubRepositoryUrl, readGitOriginRemote } from "../adapters/git.js";
+import { RecipientSessionInvalidError, resolveRecipientWorkspaceSession } from "../lib/auth/recipient.js";
+import { createManagementProjectProvider, projectRemoveBlockedError, projectRenameFailedError, projectTransferRejectedError } from "../lib/project/provider.js";
 import { createProjectUseCases } from "../use-cases/project.js";
+import path from "node:path";
+import { unlink } from "node:fs/promises";
 import { matchError } from "better-result";
 import open from "open";
 //#region src/controllers/project.ts
@@ -217,6 +224,322 @@ async function projectLinkTargetRequiredError(context, projects) {
 		})
 	});
 }
+async function runProjectRename(context, newName, options) {
+	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
+	if (!workspace) throw workspaceRequiredError();
+	const name = newName.trim();
+	if (!isValidProjectSetupName(name)) throw projectSetupNameRequiredError("project rename");
+	const { provider, target } = await requireProjectCommandContext(context, workspace, options.project, "project rename");
+	const previousName = target.project.name;
+	return {
+		command: "project.rename",
+		result: {
+			workspace,
+			project: await provider.renameProject({
+				projectId: target.project.id,
+				name,
+				signal: context.runtime.signal
+			}),
+			previousName
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runProjectRemove(context, projectRef, options) {
+	const formatCommand = resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd);
+	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
+	if (!workspace) throw workspaceRequiredError();
+	const { provider, projects } = await requireProjectMutationContext(context, workspace);
+	const project = toProjectSummary(resolveProjectForSetup(projectRef.trim(), projects, workspace));
+	requireProjectExactConfirmation({
+		id: project.id,
+		confirm: options.confirm,
+		summary: "Confirm project removal",
+		why: "Removing a project is permanent, deletes its databases, and stops its apps, so it requires the exact project id.",
+		nextStep: formatCommand([
+			"project",
+			"remove",
+			project.id,
+			"--confirm",
+			project.id
+		])
+	});
+	await provider.removeProject({
+		projectId: project.id,
+		signal: context.runtime.signal
+	});
+	const warnings = [];
+	return {
+		command: "project.remove",
+		result: {
+			workspace,
+			project,
+			localPin: { cleared: await cleanupLocalPinForProject(context, project.id, { onError: (message) => warnings.push(message) }) }
+		},
+		warnings,
+		nextSteps: []
+	};
+}
+async function runProjectTransfer(context, projectRef, options) {
+	const formatCommand = resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd);
+	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
+	if (!workspace) throw workspaceRequiredError();
+	if (options.toWorkspace && options.recipientToken) throw usageError("Choose one transfer recipient source", "--to-workspace and --recipient-token are mutually exclusive.", "Pass either --to-workspace <id-or-name> or --recipient-token <token>.", [formatCommand([
+		"project",
+		"transfer",
+		"<project>",
+		"--to-workspace",
+		"<id-or-name>",
+		"--confirm",
+		"<project-id>"
+	])], "project");
+	if (!options.toWorkspace?.trim() && !options.recipientToken?.trim()) throw transferRecipientRequiredError(formatCommand);
+	const { provider, projects } = await requireProjectMutationContext(context, workspace);
+	const project = toProjectSummary(resolveProjectForSetup(projectRef.trim(), projects, workspace));
+	requireProjectExactConfirmation({
+		id: project.id,
+		confirm: options.confirm,
+		summary: "Confirm project transfer",
+		why: "Transferring moves the project to another workspace and this workspace loses access, so it requires the exact project id.",
+		nextStep: `${formatCommand([
+			"project",
+			"transfer",
+			project.id
+		])} ${options.toWorkspace ? `--to-workspace ${formatCommandArgument(options.toWorkspace)}` : "--recipient-token <token>"} --confirm ${project.id}`
+	});
+	const recipient = await resolveTransferRecipient(context, options);
+	await provider.transferProject({
+		projectId: project.id,
+		recipientAccessToken: recipient.accessToken,
+		signal: context.runtime.signal
+	});
+	const warnings = [];
+	const pinAction = await rewriteOrClearLocalPinForProject(context, project.id, recipient.workspaceId, { onError: (message) => warnings.push(message) });
+	return {
+		command: "project.transfer",
+		result: {
+			workspace,
+			project,
+			recipient: {
+				workspaceId: recipient.workspaceId,
+				workspaceName: recipient.workspaceName,
+				source: recipient.source
+			},
+			localPin: { action: pinAction }
+		},
+		warnings,
+		nextSteps: options.toWorkspace ? [`${formatCommand([
+			"auth",
+			"workspace",
+			"use"
+		])} ${formatCommandArgument(options.toWorkspace)}`] : []
+	};
+}
+async function resolveTransferRecipient(context, options) {
+	const formatCommand = resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd);
+	const recipientToken = options.recipientToken?.trim();
+	if (recipientToken) return {
+		accessToken: recipientToken,
+		workspaceId: isRealMode(context) ? null : recipientToken,
+		workspaceName: null,
+		source: "recipient-token"
+	};
+	const workspaceRef = options.toWorkspace?.trim();
+	if (!workspaceRef) throw transferRecipientRequiredError(formatCommand);
+	if (!isRealMode(context)) {
+		const matches = context.api.listWorkspaces().filter((candidate) => candidate.id === workspaceRef || candidate.name.toLowerCase() === workspaceRef.toLowerCase());
+		if (matches.length === 0) throw workspaceNotAuthenticatedError(workspaceRef);
+		if (matches.length > 1) throw workspaceAmbiguousError(workspaceRef, matches.map((match) => ({
+			id: match.id,
+			name: match.name,
+			credentialWorkspaceId: match.id
+		})));
+		return {
+			accessToken: matches[0].id,
+			workspaceId: matches[0].id,
+			workspaceName: matches[0].name,
+			source: "workspace-session"
+		};
+	}
+	if (context.runtime.env["PRISMA_SERVICE_TOKEN"] !== void 0) throw transferRecipientUnavailableError(formatCommand);
+	try {
+		const session = await resolveRecipientWorkspaceSession(workspaceRef, context.runtime.env, context.runtime.signal);
+		return {
+			accessToken: session.accessToken,
+			workspaceId: session.workspace.id,
+			workspaceName: session.workspace.name,
+			source: "workspace-session"
+		};
+	} catch (error) {
+		if (error instanceof WorkspaceSelectionError) {
+			if (error.reason === "ambiguous") throw workspaceAmbiguousError(error.workspaceRef ?? workspaceRef, error.matches.map((match) => ({
+				id: match.id,
+				name: match.name,
+				credentialWorkspaceId: match.credentialWorkspaceId
+			})));
+			throw workspaceNotAuthenticatedError(error.workspaceRef ?? workspaceRef);
+		}
+		if (error instanceof RecipientSessionInvalidError) throw workspaceNotAuthenticatedError(error.workspaceRef);
+		throw error;
+	}
+}
+async function requireProjectMutationContext(context, workspace) {
+	if (isRealMode(context)) {
+		const client = await requireProjectClient(context);
+		return {
+			provider: createManagementProjectProvider(client),
+			projects: await listRealWorkspaceProjects(client, workspace, context.runtime.signal)
+		};
+	}
+	return {
+		provider: createFixtureProjectProvider(context),
+		projects: listFixtureWorkspaceProjects(context, workspace)
+	};
+}
+async function requireProjectCommandContext(context, workspace, explicitProject, commandName) {
+	const client = isRealMode(context) ? await requireProjectClient(context) : null;
+	const listProjects = async () => client ? listRealWorkspaceProjects(client, workspace, context.runtime.signal) : listFixtureWorkspaceProjects(context, workspace);
+	const targetResult = await resolveProjectTarget({
+		context,
+		workspace,
+		explicitProject,
+		listProjects,
+		commandName
+	});
+	if (targetResult.isErr()) throw projectResolutionErrorToCliError(targetResult.error);
+	return {
+		provider: client ? createManagementProjectProvider(client) : createFixtureProjectProvider(context),
+		target: targetResult.value
+	};
+}
+async function requireProjectClient(context) {
+	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+	if (!client) throw authRequiredError();
+	return client;
+}
+function createFixtureProjectProvider(context) {
+	const fixtureFormatCommand = resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd);
+	return {
+		async renameProject(options) {
+			const renamed = context.api.renameProject(options.projectId, options.name);
+			if (!renamed) throw projectRenameFailedError(options.name, void 0);
+			return {
+				id: renamed.id,
+				name: renamed.name,
+				...renamed.url ? { url: renamed.url } : {}
+			};
+		},
+		async removeProject(options) {
+			const removed = context.api.removeProject(options.projectId);
+			if (removed.outcome === "blocked") throw projectRemoveBlockedError(options.projectId, void 0);
+			if (removed.outcome === "not-found") throw new CliError({
+				code: "PROJECT_NOT_FOUND",
+				domain: "project",
+				summary: "Project not found",
+				why: `No project matched "${options.projectId}".`,
+				fix: `Pass a project id or name from ${fixtureFormatCommand(["project", "list"])}.`,
+				exitCode: 1,
+				nextSteps: [fixtureFormatCommand(["project", "list"])]
+			});
+		},
+		async transferProject(options) {
+			if (context.api.transferProject(options.projectId, options.recipientAccessToken).outcome !== "transferred") throw projectTransferRejectedError(options.projectId, void 0);
+		}
+	};
+}
+function requireProjectExactConfirmation(options) {
+	if (options.confirm === options.id) return;
+	throw new CliError({
+		code: "CONFIRMATION_REQUIRED",
+		domain: "project",
+		summary: options.summary,
+		why: options.why,
+		fix: `Rerun with --confirm ${options.id}.`,
+		exitCode: 2,
+		nextSteps: [options.nextStep],
+		meta: {
+			expectedConfirm: options.id,
+			receivedConfirm: options.confirm ?? null
+		}
+	});
+}
+function transferRecipientRequiredError(formatCommand) {
+	return new CliError({
+		code: "TRANSFER_RECIPIENT_REQUIRED",
+		domain: "project",
+		summary: "Transfer recipient required",
+		why: "Project transfer needs the receiving workspace.",
+		fix: "Pass --to-workspace <id-or-name> for a locally authenticated workspace, or --recipient-token <token> for a cross-account transfer.",
+		exitCode: 2,
+		nextSteps: [formatCommand([
+			"auth",
+			"workspace",
+			"list"
+		]), formatCommand([
+			"project",
+			"transfer",
+			"<project>",
+			"--to-workspace",
+			"<id-or-name>",
+			"--confirm",
+			"<project-id>"
+		])]
+	});
+}
+function transferRecipientUnavailableError(formatCommand) {
+	return new CliError({
+		code: "TRANSFER_RECIPIENT_UNAVAILABLE",
+		domain: "project",
+		summary: "Local workspace sessions are unavailable",
+		why: `--to-workspace resolves locally stored OAuth sessions, but ${SERVICE_TOKEN_ENV_VAR} is set and service-token mode does not read them.`,
+		fix: "Pass --recipient-token <token> with an access token for the receiving workspace, or unset the service token.",
+		exitCode: 1,
+		nextSteps: [formatCommand([
+			"project",
+			"transfer",
+			"<project>",
+			"--recipient-token",
+			"<token>",
+			"--confirm",
+			"<project-id>"
+		])]
+	});
+}
+async function cleanupLocalPinForProject(context, projectId, hooks) {
+	const pinResult = await readLocalResolutionPin(context.runtime.cwd, context.runtime.signal);
+	if (pinResult.isErr()) return false;
+	const pin = pinResult.value;
+	if (pin.kind !== "present" || pin.pin.projectId !== projectId) return false;
+	try {
+		await unlink(path.join(context.runtime.cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH));
+		return true;
+	} catch {
+		hooks.onError(`The local pin ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} points at the removed project but could not be deleted.`);
+		return false;
+	}
+}
+async function rewriteOrClearLocalPinForProject(context, projectId, recipientWorkspaceId, hooks) {
+	const pinResult = await readLocalResolutionPin(context.runtime.cwd, context.runtime.signal);
+	if (pinResult.isErr()) return "none";
+	const pin = pinResult.value;
+	if (pin.kind !== "present" || pin.pin.projectId !== projectId) return "none";
+	if (recipientWorkspaceId) {
+		if ((await writeLocalResolutionPin(context.runtime.cwd, {
+			workspaceId: recipientWorkspaceId,
+			projectId
+		}, context.runtime.signal)).isOk()) return "rewritten";
+		hooks.onError(`The local pin ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} points at the transferred project but could not be rewritten.`);
+		return "none";
+	}
+	try {
+		await unlink(path.join(context.runtime.cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH));
+		return "cleared";
+	} catch {
+		hooks.onError(`The local pin ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} points at the transferred project but could not be cleared.`);
+		return "none";
+	}
+}
 async function runGitConnect(context, gitUrl, options = {}) {
 	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
 	if (!workspace) throw workspaceRequiredError();
@@ -728,4 +1051,4 @@ function repoConnectionFixForStatus(status) {
 	return "Re-run with --trace for the underlying API response details.";
 }
 //#endregion
-export { listFixtureWorkspaceProjects, listRealWorkspaceProjects, runGitConnect, runGitDisconnect, runProjectCreate, runProjectLink, runProjectList, runProjectShow };
+export { listFixtureWorkspaceProjects, listRealWorkspaceProjects, runGitConnect, runGitDisconnect, runProjectCreate, runProjectLink, runProjectList, runProjectRemove, runProjectRename, runProjectShow, runProjectTransfer };

package/dist/lib/auth/recipient.js

@@ -0,0 +1,42 @@
+import { getApiBaseUrl } from "./client.js";
+import { FileTokenStorage } from "../../adapters/token-storage.js";
+import { createManagementApiSdk } from "@prisma/management-api-sdk";
+//#region src/lib/auth/recipient.ts
+var RecipientSessionInvalidError = class extends Error {
+	constructor(workspaceRef) {
+		super(`The stored session for workspace "${workspaceRef}" could not be validated.`);
+		this.workspaceRef = workspaceRef;
+		this.name = "RecipientSessionInvalidError";
+	}
+};
+/**
+* Resolve a locally stored OAuth workspace session and return a validated
+* access token for it, refreshing through the SDK when the stored token has
+* expired. The active workspace pointer is never touched.
+*
+* Throws WorkspaceSelectionError when the ref does not match exactly one
+* stored session, and RecipientSessionInvalidError when the session cannot
+* be validated or refreshed.
+*/
+async function resolveRecipientWorkspaceSession(workspaceRef, env = process.env, signal) {
+	const workspace = await new FileTokenStorage(env, signal).resolveWorkspace(workspaceRef);
+	const pinnedStorage = new FileTokenStorage(env, signal, {
+		activateOnSetTokens: false,
+		lockSetTokens: false,
+		pinnedWorkspaceId: workspace.credentialWorkspaceId
+	});
+	if ((await createManagementApiSdk({
+		clientId: "cmm3lndn701oo0uefvxzo0ivw",
+		redirectUri: "http://localhost:0/auth/callback",
+		tokenStorage: pinnedStorage,
+		apiBaseUrl: getApiBaseUrl(env)
+	}).client.GET("/v1/workspaces", { signal })).error) throw new RecipientSessionInvalidError(workspaceRef);
+	const tokens = await pinnedStorage.getTokens();
+	if (!tokens) throw new RecipientSessionInvalidError(workspaceRef);
+	return {
+		workspace,
+		accessToken: tokens.accessToken
+	};
+}
+//#endregion
+export { RecipientSessionInvalidError, resolveRecipientWorkspaceSession };

package/dist/lib/project/provider.js

@@ -0,0 +1,92 @@
+import { formatPrismaCliCommand } from "../../shell/cli-command.js";
+import { CliError } from "../../shell/errors.js";
+//#region src/lib/project/provider.ts
+function createManagementProjectProvider(client) {
+	return {
+		async renameProject(options) {
+			const result = await client.PATCH("/v1/projects/{id}", {
+				params: { path: { id: options.projectId } },
+				body: { name: options.name },
+				signal: options.signal
+			});
+			const status = result.response?.status ?? 0;
+			if (status === 400 || status === 422) throw projectRenameFailedError(options.name, result.error);
+			if (result.error || !result.data) throw projectApiError("Failed to rename project", result.response, result.error);
+			const project = result.data.data;
+			return {
+				id: project.id,
+				name: project.name,
+				...project.url ? { url: project.url } : {}
+			};
+		},
+		async removeProject(options) {
+			const result = await client.DELETE("/v1/projects/{id}", {
+				params: { path: { id: options.projectId } },
+				signal: options.signal
+			});
+			if (result.response?.status === 400) throw projectRemoveBlockedError(options.projectId, result.error);
+			if (result.error) throw projectApiError("Failed to remove project", result.response, result.error);
+		},
+		async transferProject(options) {
+			const result = await client.POST("/v1/projects/{id}/transfer", {
+				params: { path: { id: options.projectId } },
+				body: { recipientAccessToken: options.recipientAccessToken },
+				signal: options.signal
+			});
+			if (result.response?.status === 400) throw projectTransferRejectedError(options.projectId, result.error);
+			if (result.error) throw projectApiError("Failed to transfer project", result.response, result.error);
+		}
+	};
+}
+function projectRenameFailedError(name, error) {
+	return new CliError({
+		code: "PROJECT_RENAME_FAILED",
+		domain: "project",
+		summary: "Project rename failed",
+		why: error?.error?.message ?? `The platform rejected the name "${name}".`,
+		fix: error?.error?.hint ?? "Pass a different project name and retry the rename.",
+		exitCode: 1,
+		nextSteps: []
+	});
+}
+function projectRemoveBlockedError(projectId, error) {
+	return new CliError({
+		code: "PROJECT_REMOVE_BLOCKED",
+		domain: "project",
+		summary: "Project cannot be removed yet",
+		why: error?.error?.message ?? `Project "${projectId}" still has active deployments.`,
+		fix: "Remove the project's apps first, then retry the removal.",
+		exitCode: 1,
+		nextSteps: [formatPrismaCliCommand([
+			"app",
+			"remove",
+			"--app",
+			"<name>"
+		])]
+	});
+}
+function projectTransferRejectedError(projectId, error) {
+	return new CliError({
+		code: "PROJECT_TRANSFER_REJECTED",
+		domain: "project",
+		summary: "Project transfer was rejected",
+		why: error?.error?.message ?? `The platform rejected the transfer of project "${projectId}", for example because the recipient token is invalid or expired.`,
+		fix: "Check the recipient workspace session or token and retry the transfer.",
+		exitCode: 1,
+		nextSteps: []
+	});
+}
+function projectApiError(summary, response, error) {
+	const status = response?.status ?? 0;
+	return new CliError({
+		code: error?.error?.code ?? "PROJECT_API_ERROR",
+		domain: "project",
+		summary,
+		why: error?.error?.message ?? `The Management API returned status ${status || "unknown"}.`,
+		fix: error?.error?.hint ?? "Re-run with --trace for the underlying API response details.",
+		exitCode: 1,
+		nextSteps: []
+	});
+}
+//#endregion
+export { createManagementProjectProvider, projectRemoveBlockedError, projectRenameFailedError, projectTransferRejectedError };

package/dist/presenters/project.js

@@ -86,6 +86,95 @@ function renderProjectSetup(context, _descriptor, result) {
 function serializeProjectSetup(result) {
 	return result;
 }
+function renderProjectRename(context, descriptor, result) {
+	return renderMutate({
+		title: "Renaming project.",
+		descriptor,
+		context: [
+			{
+				key: "workspace",
+				value: result.workspace.name
+			},
+			{
+				key: "project",
+				value: result.previousName
+			},
+			{
+				key: "id",
+				value: result.project.id,
+				tone: "dim"
+			}
+		],
+		operationDescription: "Renaming project",
+		operationCount: 1,
+		details: [`The project is now named "${result.project.name}". Directory bindings pin the project id, so they stay valid.`]
+	}, context.ui);
+}
+function serializeProjectRename(result) {
+	return result;
+}
+function renderProjectRemove(context, descriptor, result) {
+	return renderMutate({
+		title: "Removing project.",
+		descriptor,
+		context: [
+			{
+				key: "workspace",
+				value: result.workspace.name
+			},
+			{
+				key: "project",
+				value: result.project.name
+			},
+			{
+				key: "id",
+				value: result.project.id,
+				tone: "dim"
+			}
+		],
+		operationDescription: "Removing project",
+		operationCount: 1,
+		details: ["The project, its databases, and its apps were removed.", ...result.localPin.cleared ? ["This directory's local project binding was cleared."] : []]
+	}, context.ui);
+}
+function serializeProjectRemove(result) {
+	return result;
+}
+function renderProjectTransfer(context, descriptor, result) {
+	return renderMutate({
+		title: "Transferring project.",
+		descriptor,
+		context: [
+			{
+				key: "workspace",
+				value: result.workspace.name
+			},
+			{
+				key: "project",
+				value: result.project.name
+			},
+			{
+				key: "id",
+				value: result.project.id,
+				tone: "dim"
+			},
+			{
+				key: "recipient",
+				value: result.recipient.workspaceName ?? result.recipient.workspaceId ?? "workspace of the provided recipient token"
+			}
+		],
+		operationDescription: "Transferring project",
+		operationCount: 1,
+		details: [
+			"The project now belongs to the recipient workspace; this workspace no longer has access.",
+			...result.localPin.action === "rewritten" ? ["This directory's local project binding now points at the recipient workspace."] : [],
+			...result.localPin.action === "cleared" ? ["This directory's local project binding was cleared."] : []
+		]
+	}, context.ui);
+}
+function serializeProjectTransfer(result) {
+	return result;
+}
 function renderGitConnect(context, descriptor, result) {
 	const connection = result.repositoryConnection;
 	return renderMutate({
@@ -171,4 +260,4 @@ function formatGitConnectionDetail(status) {
 	}
 }
 //#endregion
-export { renderGitConnect, renderGitDisconnect, renderProjectList, renderProjectSetup, renderProjectShow, serializeProjectList, serializeProjectSetup, serializeProjectShow };
+export { renderGitConnect, renderGitDisconnect, renderProjectList, renderProjectRemove, renderProjectRename, renderProjectSetup, renderProjectShow, renderProjectTransfer, serializeProjectList, serializeProjectRemove, serializeProjectRename, serializeProjectSetup, serializeProjectShow, serializeProjectTransfer };

package/dist/shell/command-meta.js

@@ -271,6 +271,36 @@ const DESCRIPTORS = [
 			"prisma-cli project link \"Acme Dashboard\" --json"
 		]
 	},
+	{
+		id: "project.rename",
+		path: [
+			"prisma",
+			"project",
+			"rename"
+		],
+		description: "Rename the resolved Project",
+		examples: ["prisma-cli project rename \"Acme Dashboard v2\"", "prisma-cli project rename billing-api --project proj_123"]
+	},
+	{
+		id: "project.remove",
+		path: [
+			"prisma",
+			"project",
+			"remove"
+		],
+		description: "Remove a Project permanently after exact id confirmation",
+		examples: ["prisma-cli project remove proj_123 --confirm proj_123"]
+	},
+	{
+		id: "project.transfer",
+		path: [
+			"prisma",
+			"project",
+			"transfer"
+		],
+		description: "Transfer a Project to another workspace after exact id confirmation",
+		examples: ["prisma-cli project transfer proj_123 --to-workspace \"Prisma Labs\" --confirm proj_123", "prisma-cli project transfer proj_123 --recipient-token <token> --confirm proj_123"]
+	},
 	{
 		id: "git.connect",
 		path: [

package/dist/shell/command-runner.js

@@ -1,5 +1,6 @@
 import { CliError, authConfigInvalidError, authRequiredError, commandCanceledError } from "./errors.js";
 import { getCommandDescriptor } from "./command-meta.js";
+import { renderSummaryLine } from "./ui.js";
 import { resolveGlobalFlags } from "./global-flags.js";
 import { createCommandContext } from "./runtime.js";
 import { collectCommandDiagnostics } from "../lib/diagnostics.js";
@@ -48,11 +49,16 @@ async function writeCommandSuccess(context, descriptor, success, presenter, dura
 		return;
 	}
 	const rendered = presenter.renderHuman(context, descriptor, success.result);
+	const warningLines = success.warnings.map((warning) => renderSummaryLine(context.ui, "warning", warning));
 	const diagnostics = await renderBestEffortCommandDiagnostics(context, {
 		enabled: context.flags.verbose && rendered.length > 0,
 		durationMs
 	});
-	const humanLines = [...rendered, ...diagnostics];
+	const humanLines = [
+		...rendered,
+		...warningLines,
+		...diagnostics
+	];
 	if (stdout.length > 0 && humanLines.length > 0) humanLines.push("");
 	writeHumanLines(context.output, humanLines);
 	writeStdoutLines(context, stdout);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-dev.114.1",
+  "version": "3.0.0-dev.115.1",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {