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

package/dist/controllers/project.js

@@ -1,30 +1,33 @@
-import { CliError, authRequiredError, featureUnavailableError, usageError, workspaceRequiredError } from "../shell/errors.js";
-import { createAppProvider } from "../lib/app/app-provider.js";
+import { resolvePrismaCliPackageCommandFormatterSync } from "../lib/agent/cli-command.js";
+import { formatCommandArgument } from "../command-arguments.js";
+import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../errors.js";
 import { renderSummaryLine } from "../shell/ui.js";
+import { WorkspaceSelectionError } from "../auth/token-storage.js";
+import { authenticatedManagementApiClient } from "../auth/guard.js";
 import { canPrompt } from "../shell/runtime.js";
-import { readLocalResolutionPin } from "../lib/project/local-pin.js";
-import { formatCommandArgument } from "../shell/command-arguments.js";
+import { createAppProvider } from "../lib/app/app-provider.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";
 import { promptForProjectSetupChoice } from "../lib/project/interactive-setup.js";
-import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
+import { workspaceAmbiguousError, workspaceNotAuthenticatedError } from "../auth/errors.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
 import { parseGitHubRepositoryUrl, readGitOriginRemote } from "../adapters/git.js";
-import { createProjectUseCases } from "../use-cases/project.js";
-import { matchError } from "better-result";
+import { RecipientSessionInvalidError, resolveRecipientWorkspaceSession } from "../auth/recipient.js";
+import { createManagementProjectProvider, projectApiError } from "../lib/project/provider.js";
+import path from "node:path";
+import { unlink } from "node:fs/promises";
+import { SERVICE_TOKEN_ENV_VAR } from "@prisma/cli-engine";
 import open from "open";
+import { matchError } from "better-result";
 //#region src/controllers/project.ts
 const GITHUB_INSTALL_POLL_INTERVAL_MS = 2e3;
 const GITHUB_INSTALL_POLL_TIMEOUT_MS = 12e4;
-function isRealMode(context) {
-	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
-}
-async function readProjectListLocalBinding(cwd, workspace, projects, signal) {
+async function readProjectListLocalBinding(cwd, projects, signal) {
 	const pinResult = await readLocalResolutionPin(cwd, signal);
 	if (pinResult.isErr()) return localPinReadErrorToInvalidLocalBinding(pinResult.error);
 	const pin = pinResult.value;
-	if (pin.kind === "present") return pin.pin.workspaceId === workspace.id && projects.some((project) => project.id === pin.pin.projectId) ? { status: "linked" } : { status: "invalid" };
+	if (pin.kind === "present") return projects.some((project) => project.id === pin.pin.projectId) ? { status: "linked" } : { status: "invalid" };
 	return { status: "not-linked" };
 }
 function localPinReadErrorToInvalidLocalBinding(error) {
@@ -40,34 +43,18 @@ function localPinReadErrorToInvalidLocalBinding(error) {
 	});
 }
 async function runProjectList(context) {
-	const authState = await requireAuthenticatedAuthState(context);
-	const workspace = authState.workspace;
+	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
 	if (!workspace) throw workspaceRequiredError();
-	if (isRealMode(context)) {
-		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
-		if (!client) throw authRequiredError();
-		const projects = sortProjects(await listRealWorkspaceProjects(client, workspace, context.runtime.signal));
-		const localBinding = await readProjectListLocalBinding(context.runtime.cwd, workspace, projects, context.runtime.signal);
-		const nextActions = buildProjectListNextActions(localBinding);
-		return {
-			command: "project.list",
-			result: {
-				workspace,
-				projects: projects.map(toProjectSummary),
-				localBinding
-			},
-			warnings: [],
-			nextSteps: [],
-			nextActions
-		};
-	}
-	const result = await createProjectUseCases(createCliUseCaseGateways(context)).list(authState);
-	const localBinding = await readProjectListLocalBinding(context.runtime.cwd, workspace, result.projects, context.runtime.signal);
+	const client = await authenticatedManagementApiClient(context.runtime.env, context.runtime.signal);
+	if (!client) throw authRequiredError();
+	const projects = sortProjects(await listRealWorkspaceProjects(client, context.runtime.signal));
+	const localBinding = await readProjectListLocalBinding(context.runtime.cwd, projects, context.runtime.signal);
 	const nextActions = buildProjectListNextActions(localBinding);
 	return {
 		command: "project.list",
 		result: {
-			...result,
+			workspace,
+			projects: projects.map(toProjectSummary),
 			localBinding
 		},
 		warnings: [],
@@ -84,7 +71,7 @@ function buildProjectListNextActions(localBinding) {
 async function runProjectShow(context, explicitProject) {
 	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
 	if (!workspace) throw workspaceRequiredError();
-	const result = isRealMode(context) ? await resolveProjectShowInRealMode(context, workspace, explicitProject) : await resolveProjectShowInFixtureMode(context, workspace, explicitProject);
+	const result = await resolveProjectShowInRealMode(context, workspace, explicitProject);
 	return {
 		command: "project.show",
 		result,
@@ -97,17 +84,17 @@ async function runProjectShow(context, explicitProject) {
 		}) : []
 	};
 }
-async function runProjectCreate(context, projectName) {
+async function runProjectCreate(context, projectName, options) {
 	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
 	if (!workspace) throw workspaceRequiredError();
 	if (!isValidProjectSetupName(projectName)) throw projectSetupNameRequiredError("project create");
-	if (!isRealMode(context)) throw featureUnavailableError("Project create is not available in fixture mode", "Creating Projects requires live platform integration.", "Rerun without fixture mode enabled to create a Project.", ["prisma-cli auth login"], "project");
-	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+	const client = await authenticatedManagementApiClient(context.runtime.env, context.runtime.signal);
 	if (!client) throw authRequiredError();
 	const provider = createAppProvider(client);
 	const name = projectName.trim();
 	const created = await provider.createProject({
 		name,
+		region: options?.region,
 		signal: context.runtime.signal
 	}).catch((error) => {
 		throw projectCreateFailedError(error, name, workspace, {
@@ -118,7 +105,8 @@ async function runProjectCreate(context, projectName) {
 	});
 	const bindResult = await bindProjectToDirectory(context, workspace, {
 		id: created.id,
-		name: created.name
+		name: created.name,
+		...created.defaultRegion != null ? { defaultRegion: created.defaultRegion } : {}
 	}, "created");
 	if (bindResult.isErr()) throw projectDirectoryBindingErrorToCliError(bindResult.error);
 	return {
@@ -131,14 +119,10 @@ async function runProjectCreate(context, projectName) {
 async function runProjectLink(context, projectRef) {
 	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
 	if (!workspace) throw workspaceRequiredError();
-	let provider = null;
-	let projects;
-	if (isRealMode(context)) {
-		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
-		if (!client) throw authRequiredError();
-		provider = createAppProvider(client);
-		projects = await listRealWorkspaceProjects(client, workspace, context.runtime.signal);
-	} else projects = listFixtureWorkspaceProjects(context, workspace);
+	const client = await authenticatedManagementApiClient(context.runtime.env, context.runtime.signal);
+	if (!client) throw authRequiredError();
+	const provider = createAppProvider(client);
+	const projects = await listRealWorkspaceProjects(client, context.runtime.signal);
 	let result;
 	if (projectRef?.trim()) result = await requireProjectDirectoryBinding(context, workspace, toProjectSummary(resolveProjectForSetup(projectRef.trim(), projects, workspace)), "linked");
 	else if (canPrompt(context) && !context.flags.yes) result = await resolveInteractiveProjectLinkSetup(context, workspace, projects, provider);
@@ -154,10 +138,7 @@ async function resolveInteractiveProjectLinkSetup(context, workspace, projects,
 	const setup = await promptForProjectSetupChoice({
 		context,
 		projects,
-		createProject: (projectName) => {
-			if (!provider) throw featureUnavailableError("Project create is not available in fixture mode", "Creating Projects requires live platform integration.", "Rerun without fixture mode enabled to create a Project.", ["prisma-cli auth login"], "project");
-			return createProjectForLinkSetup(provider, projectName, workspace, context.runtime.signal);
-		},
+		createProject: (projectName) => createProjectForLinkSetup(provider, projectName, workspace, context.runtime.signal),
 		cancel: {
 			why: "Project link needs a Project before it can continue.",
 			fix: "Choose an existing Project or create a new one, then rerun project link.",
@@ -217,54 +198,288 @@ async function projectLinkTargetRequiredError(context, projects) {
 		})
 	});
 }
-async function runGitConnect(context, gitUrl, options = {}) {
+async function runProjectRename(context, newName, options) {
 	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
 	if (!workspace) throw workspaceRequiredError();
-	if (isRealMode(context)) {
-		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
-		if (!client) throw authRequiredError();
-		const target = await resolveRequiredProjectInRealMode(context, workspace, options.project, "git connect");
-		const repository = await resolveRepositoryForConnect(context, gitUrl);
-		const api = client;
-		const existing = await readFirstSourceRepository(api, target.project.id, context.runtime.signal);
-		if (existing) {
-			const existingConnection = toRepositoryConnection(existing);
-			if (repositoryFullNamesMatch(existingConnection.repository.fullName, repository.fullName)) return {
-				command: "git.connect",
-				result: {
-					...target,
-					repositoryConnection: existingConnection
-				},
-				warnings: [],
-				nextSteps: []
-			};
-			throw repoAlreadyConnectedError(existingConnection.repository.fullName);
-		}
-		const resolvedRepository = await resolveInstalledRepository(context, api, workspace.id, repository);
-		const { data, error, response } = await api.POST("/v1/source-repositories", {
-			body: {
+	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,
-				provider: "github",
-				providerRepositoryId: resolvedRepository.repository.id,
-				installationId: resolvedRepository.installation.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
 			},
-			signal: context.runtime.signal
-		});
-		if (error || !data) throw repoConnectionApiError("Failed to connect GitHub repository", response, error);
+			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: null,
+		workspaceName: null,
+		source: "recipient-token"
+	};
+	const workspaceRef = options.toWorkspace?.trim();
+	if (!workspaceRef) throw transferRecipientRequiredError(formatCommand);
+	if (context.runtime.env[SERVICE_TOKEN_ENV_VAR] !== void 0) throw transferRecipientUnavailableError(formatCommand);
+	return resolveTransferRecipientFromWorkspaceSession(context, workspaceRef);
+}
+async function resolveTransferRecipientFromWorkspaceSession(context, workspaceRef) {
+	try {
+		const session = await resolveRecipientWorkspaceSession(workspaceRef, context.runtime.env, context.runtime.signal);
 		return {
-			command: "git.connect",
-			result: {
-				...target,
-				repositoryConnection: toRepositoryConnection(data.data)
-			},
-			warnings: [],
-			nextSteps: []
+			accessToken: session.accessToken,
+			workspaceId: session.workspace.id,
+			workspaceName: session.workspace.name,
+			source: "workspace-session"
 		};
+	} catch (error) {
+		throw recipientWorkspaceSessionFailure(error, workspaceRef);
 	}
-	const target = await resolveRequiredProjectInFixtureMode(context, workspace, options.project, "git connect");
+}
+function recipientWorkspaceSessionFailure(error, workspaceRef) {
+	if (error instanceof WorkspaceSelectionError) {
+		if (error.reason === "ambiguous") return workspaceAmbiguousError(error.workspaceRef ?? workspaceRef, error.matches.map((match) => ({
+			id: match.id,
+			name: match.name,
+			credentialWorkspaceId: match.credentialWorkspaceId
+		})));
+		return workspaceNotAuthenticatedError(error.workspaceRef ?? workspaceRef);
+	}
+	if (error instanceof RecipientSessionInvalidError) return workspaceNotAuthenticatedError(error.workspaceRef);
+	return error;
+}
+async function requireProjectMutationContext(context, _workspace) {
+	const client = await requireProjectClient(context);
+	return {
+		provider: createManagementProjectProvider(client),
+		projects: await listRealWorkspaceProjects(client, context.runtime.signal)
+	};
+}
+async function requireProjectCommandContext(context, workspace, explicitProject, commandName) {
+	const client = await requireProjectClient(context);
+	const listProjects = async () => listRealWorkspaceProjects(client, context.runtime.signal);
+	const targetResult = await resolveProjectTarget({
+		context,
+		workspace,
+		explicitProject,
+		listProjects,
+		commandName
+	});
+	if (targetResult.isErr()) throw projectResolutionErrorToCliError(targetResult.error);
+	return {
+		provider: createManagementProjectProvider(client),
+		target: targetResult.value
+	};
+}
+async function requireProjectClient(context) {
+	const client = await authenticatedManagementApiClient(context.runtime.env, context.runtime.signal);
+	if (!client) throw authRequiredError();
+	return client;
+}
+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();
+	const client = await authenticatedManagementApiClient(context.runtime.env, context.runtime.signal);
+	if (!client) throw authRequiredError();
+	const target = await resolveRequiredProjectInRealMode(context, workspace, options.project, "git connect");
 	const repository = await resolveRepositoryForConnect(context, gitUrl);
-	const existingConnection = await context.stateStore.readRepositoryConnection(target.project.id);
-	if (existingConnection) {
+	const api = client;
+	const existing = await readFirstSourceRepository(api, target.project.id, context.runtime.signal);
+	if (existing) {
+		const existingConnection = toRepositoryConnection(existing);
 		if (repositoryFullNamesMatch(existingConnection.repository.fullName, repository.fullName)) return {
 			command: "git.connect",
 			result: {
@@ -276,13 +491,22 @@ async function runGitConnect(context, gitUrl, options = {}) {
 		};
 		throw repoAlreadyConnectedError(existingConnection.repository.fullName);
 	}
-	const connection = createPendingRepositoryConnection(repository);
-	await context.stateStore.setRepositoryConnection(target.project.id, connection);
+	const resolvedRepository = await resolveInstalledRepository(context, api, workspace.id, repository);
+	const { data, error, response } = await api.POST("/v1/source-repositories", {
+		body: {
+			projectId: target.project.id,
+			provider: "github",
+			providerRepositoryId: resolvedRepository.repository.id,
+			installationId: resolvedRepository.installation.id
+		},
+		signal: context.runtime.signal
+	});
+	if (error || !data) throw repoConnectionApiError("Failed to connect GitHub repository", response, error);
 	return {
 		command: "git.connect",
 		result: {
 			...target,
-			repositoryConnection: connection
+			repositoryConnection: toRepositoryConnection(data.data)
 		},
 		warnings: [],
 		nextSteps: []
@@ -291,96 +515,64 @@ async function runGitConnect(context, gitUrl, options = {}) {
 async function runGitDisconnect(context, options = {}) {
 	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
 	if (!workspace) throw workspaceRequiredError();
-	if (isRealMode(context)) {
-		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
-		if (!client) throw authRequiredError();
-		const target = await resolveRequiredProjectInRealMode(context, workspace, options.project, "git disconnect");
-		const api = client;
-		const existing = await readFirstSourceRepository(api, target.project.id, context.runtime.signal);
-		if (!existing) throw repoNotConnectedError();
-		const { error, response } = await api.DELETE("/v1/source-repositories/{id}", {
-			params: { path: { id: existing.id } },
-			signal: context.runtime.signal
-		});
-		if (error) throw repoConnectionApiError("Failed to disconnect GitHub repository", response, error);
-		return {
-			command: "git.disconnect",
-			result: {
-				...target,
-				repositoryConnection: toRepositoryConnection(existing)
-			},
-			warnings: [],
-			nextSteps: []
-		};
-	}
-	const target = await resolveRequiredProjectInFixtureMode(context, workspace, options.project, "git disconnect");
-	const existingConnection = await context.stateStore.readRepositoryConnection(target.project.id);
-	if (!existingConnection) throw repoNotConnectedError();
-	await context.stateStore.clearRepositoryConnection(target.project.id);
+	const client = await authenticatedManagementApiClient(context.runtime.env, context.runtime.signal);
+	if (!client) throw authRequiredError();
+	const target = await resolveRequiredProjectInRealMode(context, workspace, options.project, "git disconnect");
+	const api = client;
+	const existing = await readFirstSourceRepository(api, target.project.id, context.runtime.signal);
+	if (!existing) throw repoNotConnectedError();
+	const { error, response } = await api.DELETE("/v1/source-repositories/{id}", {
+		params: { path: { id: existing.id } },
+		signal: context.runtime.signal
+	});
+	if (error) throw repoConnectionApiError("Failed to disconnect GitHub repository", response, error);
 	return {
 		command: "git.disconnect",
 		result: {
 			...target,
-			repositoryConnection: existingConnection
+			repositoryConnection: toRepositoryConnection(existing)
 		},
 		warnings: [],
 		nextSteps: []
 	};
 }
 async function resolveProjectShowInRealMode(context, workspace, explicitProject) {
-	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+	const client = await authenticatedManagementApiClient(context.runtime.env, context.runtime.signal);
 	if (!client) throw authRequiredError();
 	const result = await inspectProjectBinding({
 		context,
 		workspace,
 		explicitProject,
-		listProjects: () => listRealWorkspaceProjects(client, workspace, context.runtime.signal),
+		listProjects: () => listRealWorkspaceProjects(client, context.runtime.signal),
 		commandName: "project show"
 	});
 	if (result.isErr()) throw projectResolutionErrorToCliError(result.error);
 	return result.value;
 }
 async function resolveRequiredProjectInRealMode(context, workspace, explicitProject, commandName) {
-	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+	const client = await authenticatedManagementApiClient(context.runtime.env, context.runtime.signal);
 	if (!client) throw authRequiredError();
 	const result = await resolveProjectTarget({
 		context,
 		workspace,
 		explicitProject,
-		listProjects: () => listRealWorkspaceProjects(client, workspace, context.runtime.signal),
+		listProjects: () => listRealWorkspaceProjects(client, context.runtime.signal),
 		commandName
 	});
 	if (result.isErr()) throw projectResolutionErrorToCliError(result.error);
 	return result.value;
 }
-async function resolveProjectShowInFixtureMode(context, workspace, explicitProject) {
-	const result = await inspectProjectBinding({
-		context,
-		workspace,
-		explicitProject,
-		listProjects: async () => listFixtureWorkspaceProjects(context, workspace),
-		commandName: "project show"
-	});
-	if (result.isErr()) throw projectResolutionErrorToCliError(result.error);
-	return result.value;
-}
-async function resolveRequiredProjectInFixtureMode(context, workspace, explicitProject, commandName) {
-	const result = await resolveProjectTarget({
-		context,
-		workspace,
-		explicitProject,
-		listProjects: async () => listFixtureWorkspaceProjects(context, workspace),
-		commandName
-	});
-	if (result.isErr()) throw projectResolutionErrorToCliError(result.error);
-	return result.value;
-}
-async function listRealWorkspaceProjects(client, workspace, signal) {
-	const { data } = await client.GET("/v1/projects", { signal });
-	return sortProjects((data?.data ?? []).filter((project) => project.workspace.id === workspace.id).map((project) => ({
+/** The projects the API returns for the active credential, sorted.
+*  Takes no workspace: the credential names one, and the API answers
+*  within it. */
+async function listRealWorkspaceProjects(client, signal) {
+	const { data, error, response } = await client.GET("/v1/projects", { signal });
+	if (error || !data) throw projectApiError("Failed to list projects", response, error);
+	return sortProjects((data.data ?? []).map((project) => ({
 		id: project.id,
 		name: project.name,
 		..."url" in project && typeof project.url === "string" ? { url: project.url } : {},
+		..."defaultRegion" in project ? { defaultRegion: project.defaultRegion } : {},
 		slug: "slug" in project && typeof project.slug === "string" ? project.slug : null,
 		workspace: {
 			id: project.workspace.id,
@@ -388,15 +580,6 @@ async function listRealWorkspaceProjects(client, workspace, signal) {
 		}
 	})));
 }
-function listFixtureWorkspaceProjects(context, workspace) {
-	return sortProjects(context.api.listProjectsForWorkspace(workspace.id).map((project) => ({
-		id: project.id,
-		name: project.name,
-		...project.url ? { url: project.url } : {},
-		slug: project.slug,
-		workspace
-	})));
-}
 async function resolveRepositoryForConnect(context, gitUrl) {
 	const remoteUrl = gitUrl ?? await readGitOriginRemote(context.runtime.cwd, context.runtime.signal);
 	if (!remoteUrl) throw usageError("Repository connection requires a GitHub repository URL", "No git-url was provided and the local repo does not have an origin remote.", "Pass a GitHub repository URL, or add a GitHub origin remote and rerun prisma-cli git connect.", ["prisma-cli git connect git@github.com:prisma/prisma-cli.git"], "project");
@@ -582,28 +765,6 @@ async function readFirstSourceRepository(api, projectId, signal) {
 	if (error || !data) throw repoConnectionApiError("Failed to inspect GitHub repository connection", response, error);
 	return data.data[0] ?? null;
 }
-function createPendingRepositoryConnection(repository) {
-	return {
-		id: null,
-		provider: "github",
-		repoId: null,
-		repository,
-		defaultBranch: null,
-		isPrivate: null,
-		status: "pending",
-		installation: {
-			id: null,
-			status: "pending"
-		},
-		automation: {
-			branches: false,
-			pullRequests: false,
-			comments: false
-		},
-		connectedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		updatedAt: null
-	};
-}
 function toRepositoryConnection(record) {
 	const [owner = "", name = ""] = record.repoFullName.split("/");
 	return {
@@ -728,4 +889,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 { listRealWorkspaceProjects, runGitConnect, runGitDisconnect, runProjectCreate, runProjectLink, runProjectList, runProjectRemove, runProjectRename, runProjectShow, runProjectTransfer };