@prisma/cli 8.0.0-rc.1 → 8.0.0-rc.2-dev.49

package/dist/controllers/project.js

@@ -1,892 +0,0 @@
-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 { 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 { promptForProjectSetupChoice } from "../lib/project/interactive-setup.js";
-import { workspaceAmbiguousError, workspaceNotAuthenticatedError } from "../auth/errors.js";
-import { requireAuthenticatedAuthState } from "./auth.js";
-import { parseGitHubRepositoryUrl, readGitOriginRemote } from "../adapters/git.js";
-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;
-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 projects.some((project) => project.id === pin.pin.projectId) ? { status: "linked" } : { status: "invalid" };
-	return { status: "not-linked" };
-}
-function localPinReadErrorToInvalidLocalBinding(error) {
-	return matchError(error, {
-		LocalResolutionPinInvalidJsonError: () => ({ status: "invalid" }),
-		LocalResolutionPinInvalidShapeError: () => ({ status: "invalid" }),
-		LocalResolutionPinReadAbortedError: (error) => {
-			throw error;
-		},
-		UnhandledException: (error) => {
-			throw error;
-		}
-	});
-}
-async function runProjectList(context) {
-	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 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: {
-			workspace,
-			projects: projects.map(toProjectSummary),
-			localBinding
-		},
-		warnings: [],
-		nextSteps: [],
-		nextActions
-	};
-}
-function buildProjectListNextActions(localBinding) {
-	return localBinding?.status === "linked" ? [] : buildProjectSetupNextActions({
-		createCommand: "prisma-cli project create <name>",
-		reason: localBinding?.status === "invalid" ? "This directory has an invalid local Project binding. Ask the user which Prisma Project to link before running Project-scoped commands." : "This directory is not linked to a Prisma Project. Project list shows available Projects, but none is selected for this directory."
-	});
-}
-async function runProjectShow(context, explicitProject) {
-	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
-	if (!workspace) throw workspaceRequiredError();
-	const result = await resolveProjectShowInRealMode(context, workspace, explicitProject);
-	return {
-		command: "project.show",
-		result,
-		warnings: [],
-		nextSteps: [],
-		nextActions: result.project === null ? buildProjectSetupNextActions({
-			commandName: "project show",
-			suggestedProjectName: result.suggestedProjectName,
-			reason: "This directory is not linked to a Prisma Project. Package and directory names can suggest setup defaults, but they do not select a Project."
-		}) : []
-	};
-}
-async function runProjectCreate(context, projectName, options) {
-	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
-	if (!workspace) throw workspaceRequiredError();
-	if (!isValidProjectSetupName(projectName)) throw projectSetupNameRequiredError("project create");
-	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, {
-			nextSteps: ["prisma-cli project list", "prisma-cli project link <id-or-name>"],
-			permissionFix: "Grant the token permission to create Projects in this workspace, or link an existing Project.",
-			fallbackFix: "Retry the command, or choose an existing Project with prisma-cli project link <id-or-name>."
-		});
-	});
-	const bindResult = await bindProjectToDirectory(context, workspace, {
-		id: created.id,
-		name: created.name,
-		...created.defaultRegion != null ? { defaultRegion: created.defaultRegion } : {}
-	}, "created");
-	if (bindResult.isErr()) throw projectDirectoryBindingErrorToCliError(bindResult.error);
-	return {
-		command: "project.create",
-		result: bindResult.value,
-		warnings: [],
-		nextSteps: ["prisma-cli app deploy"]
-	};
-}
-async function runProjectLink(context, projectRef) {
-	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 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);
-	else throw await projectLinkTargetRequiredError(context, projects);
-	return {
-		command: "project.link",
-		result,
-		warnings: [],
-		nextSteps: ["prisma-cli app deploy"]
-	};
-}
-async function resolveInteractiveProjectLinkSetup(context, workspace, projects, provider) {
-	const setup = await promptForProjectSetupChoice({
-		context,
-		projects,
-		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.",
-			nextSteps: ["prisma-cli project link <id-or-name>", "prisma-cli project create <name>"]
-		}
-	});
-	return requireProjectDirectoryBinding(context, workspace, setup.project, setup.action);
-}
-async function requireProjectDirectoryBinding(context, workspace, project, action) {
-	const bindResult = await bindProjectToDirectory(context, workspace, project, action);
-	if (bindResult.isErr()) throw projectDirectoryBindingErrorToCliError(bindResult.error);
-	return bindResult.value;
-}
-async function createProjectForLinkSetup(provider, projectName, workspace, signal) {
-	const created = await provider.createProject({
-		name: projectName,
-		signal
-	}).catch((error) => {
-		throw projectCreateFailedError(error, projectName, workspace, {
-			nextSteps: [
-				"prisma-cli project list",
-				"prisma-cli project link <id-or-name>",
-				`prisma-cli project create ${formatCommandArgument(projectName)}`
-			],
-			permissionFix: "Grant the token permission to create Projects in this workspace, or link an existing Project.",
-			fallbackFix: "Retry the command, or choose an existing Project with prisma-cli project link <id-or-name>."
-		});
-	});
-	return {
-		id: created.id,
-		name: created.name,
-		workspace
-	};
-}
-async function projectLinkTargetRequiredError(context, projects) {
-	const suggestedName = await inferTargetName(context.runtime.cwd, context.runtime.signal);
-	const createCommand = `prisma-cli project create ${formatCommandArgument(suggestedName.name)}`;
-	const recoveryCommands = ["prisma-cli project link <id-or-name>", createCommand];
-	return new CliError({
-		code: "PROJECT_LINK_TARGET_REQUIRED",
-		domain: "project",
-		summary: "Choose a Project to link this directory",
-		why: "This directory is not linked to a Prisma Project. Existing Projects are candidates until the user chooses one, and package or directory names are suggestions only.",
-		fix: "Run prisma-cli project link in a TTY to choose from the setup list, pass a Project id or name, or create a new Project.",
-		meta: {
-			suggestedProjectName: suggestedName.name,
-			suggestedProjectNameSource: suggestedName.source,
-			candidates: sortProjects(projects).map(toProjectSummary),
-			recoveryCommands
-		},
-		exitCode: 2,
-		nextSteps: ["prisma-cli project list", ...recoveryCommands],
-		nextActions: buildProjectSetupNextActions({
-			suggestedProjectName: suggestedName.name,
-			createCommand,
-			reason: "Project link needs the user to choose an existing Project or create a new one. Existing Projects, package names, and directory names are candidates only, not selections."
-		})
-	});
-}
-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: 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 {
-			accessToken: session.accessToken,
-			workspaceId: session.workspace.id,
-			workspaceName: session.workspace.name,
-			source: "workspace-session"
-		};
-	} catch (error) {
-		throw recipientWorkspaceSessionFailure(error, workspaceRef);
-	}
-}
-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 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: {
-			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: toRepositoryConnection(data.data)
-		},
-		warnings: [],
-		nextSteps: []
-	};
-}
-async function runGitDisconnect(context, 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 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: []
-	};
-}
-async function resolveProjectShowInRealMode(context, workspace, explicitProject) {
-	const client = await authenticatedManagementApiClient(context.runtime.env, context.runtime.signal);
-	if (!client) throw authRequiredError();
-	const result = await inspectProjectBinding({
-		context,
-		workspace,
-		explicitProject,
-		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 authenticatedManagementApiClient(context.runtime.env, context.runtime.signal);
-	if (!client) throw authRequiredError();
-	const result = await resolveProjectTarget({
-		context,
-		workspace,
-		explicitProject,
-		listProjects: () => listRealWorkspaceProjects(client, context.runtime.signal),
-		commandName
-	});
-	if (result.isErr()) throw projectResolutionErrorToCliError(result.error);
-	return result.value;
-}
-/** 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,
-			name: project.workspace.name
-		}
-	})));
-}
-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");
-	const repository = parseGitHubRepositoryUrl(remoteUrl);
-	if (!repository) throw unsupportedRepositoryProviderError();
-	return repository;
-}
-async function resolveInstalledRepository(context, api, workspaceId, repository) {
-	const lookup = await findRepositoryInInstallations(api, await listScmInstallations(api, workspaceId, context.runtime.signal), repository, context.runtime.signal);
-	if (lookup.match) return lookup.match;
-	const installUrl = await createGitHubInstallIntent(api, workspaceId, context.runtime.signal);
-	const canWait = canPrompt(context);
-	const opened = await openInstallUrlIfInteractive(context, installUrl);
-	if (!canWait) {
-		if (lookup.inspectableInstallationCount > 0) throw repoNotAccessibleError(repository, installUrl, opened);
-		throw repoInstallationRequiredError(repository, installUrl, opened);
-	}
-	writeInstallWaitStatus(context, opened, installUrl);
-	const result = await waitForInstalledRepository(context, api, workspaceId, repository);
-	if (result.match) return result.match;
-	if (result.inspectableInstallationCount > 0) throw repoNotAccessibleError(repository, installUrl, opened);
-	throw repoInstallationRequiredError(repository, installUrl, opened);
-}
-async function findRepositoryInInstallations(api, installations, repository, signal) {
-	let inspectableInstallationCount = 0;
-	for (const installation of installations) {
-		if (installation.provider !== "github" || installation.suspended) continue;
-		const matchedRepository = await findRepositoryInInstallationIfAvailable(api, installation.id, repository, signal);
-		if (matchedRepository === "unavailable") continue;
-		inspectableInstallationCount += 1;
-		if (matchedRepository) return {
-			match: {
-				installation,
-				repository: matchedRepository
-			},
-			inspectableInstallationCount
-		};
-	}
-	return {
-		match: null,
-		inspectableInstallationCount
-	};
-}
-async function waitForInstalledRepository(context, api, workspaceId, repository) {
-	const timeoutMs = readPositiveIntegerEnv(context.runtime.env.PRISMA_CLI_GITHUB_INSTALL_TIMEOUT_MS, GITHUB_INSTALL_POLL_TIMEOUT_MS);
-	const intervalMs = readPositiveIntegerEnv(context.runtime.env.PRISMA_CLI_GITHUB_INSTALL_POLL_INTERVAL_MS, GITHUB_INSTALL_POLL_INTERVAL_MS);
-	const deadline = Date.now() + timeoutMs;
-	let inspectableInstallationCount = 0;
-	while (Date.now() <= deadline) {
-		context.runtime.signal.throwIfAborted();
-		const lookup = await findRepositoryInInstallations(api, await listScmInstallations(api, workspaceId, context.runtime.signal), repository, context.runtime.signal);
-		inspectableInstallationCount = lookup.inspectableInstallationCount;
-		if (lookup.match) return {
-			match: lookup.match,
-			inspectableInstallationCount
-		};
-		const remainingMs = deadline - Date.now();
-		if (remainingMs <= 0) break;
-		await sleep(Math.min(intervalMs, remainingMs), context.runtime.signal);
-	}
-	return {
-		match: null,
-		inspectableInstallationCount
-	};
-}
-function readPositiveIntegerEnv(value, fallback) {
-	if (value === void 0) return fallback;
-	const parsed = Number(value);
-	return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
-}
-function writeInstallWaitStatus(context, opened, installUrl) {
-	if (context.flags.quiet) return;
-	const lines = [renderSummaryLine(context.ui, "info", opened ? "Waiting for GitHub App installation or repository access approval..." : "Waiting for GitHub App installation or repository access approval. Open the install URL in your browser.")];
-	if (!opened) lines.push(installUrl);
-	context.output.stderr.write(`${lines.join("\n")}\n`);
-}
-function sleep(ms, signal) {
-	signal.throwIfAborted();
-	return new Promise((resolve, reject) => {
-		const onAbort = () => {
-			clearTimeout(timeout);
-			reject(signal.reason);
-		};
-		const timeout = setTimeout(() => {
-			signal.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		signal.addEventListener("abort", onAbort, { once: true });
-	});
-}
-async function listScmInstallations(api, workspaceId, signal) {
-	const installations = [];
-	let cursor;
-	const seenCursors = /* @__PURE__ */ new Set();
-	do {
-		const { data, error, response } = await api.GET("/v1/scm-installations", {
-			params: { query: {
-				workspaceId,
-				limit: 100,
-				...cursor ? { cursor } : {}
-			} },
-			signal
-		});
-		if (error || !data) throw repoConnectionApiError("Failed to inspect GitHub App installations", response, error);
-		installations.push(...data.data);
-		cursor = readNextPaginationCursor(data.pagination, seenCursors, "Failed to inspect GitHub App installations", response);
-	} while (cursor);
-	return installations;
-}
-async function findRepositoryInInstallation(api, installationId, repository, signal) {
-	const expectedFullName = repository.fullName.toLowerCase();
-	let cursor;
-	const seenCursors = /* @__PURE__ */ new Set();
-	do {
-		const { data, error, response } = await api.GET("/v1/scm-installations/{installationId}/repositories", {
-			params: {
-				path: { installationId },
-				query: {
-					limit: 100,
-					...cursor ? { cursor } : {}
-				}
-			},
-			signal
-		});
-		if (error || !data) throw repoConnectionApiError("Failed to inspect GitHub repositories", response, error);
-		const matchedRepository = data.data.find((candidate) => candidate.fullName.toLowerCase() === expectedFullName);
-		if (matchedRepository) return matchedRepository;
-		cursor = readNextPaginationCursor(data.pagination, seenCursors, "Failed to inspect GitHub repositories", response);
-	} while (cursor);
-	return null;
-}
-function readNextPaginationCursor(pagination, seenCursors, summary, response) {
-	const nextCursor = pagination.hasMore && pagination.nextCursor ? pagination.nextCursor : void 0;
-	if (!nextCursor) return;
-	if (seenCursors.has(nextCursor)) throw repoConnectionApiError(summary, response, { error: { message: "Pagination cursor did not advance." } });
-	seenCursors.add(nextCursor);
-	return nextCursor;
-}
-async function findRepositoryInInstallationIfAvailable(api, installationId, repository, signal) {
-	try {
-		return await findRepositoryInInstallation(api, installationId, repository, signal);
-	} catch (error) {
-		if (signal.aborted) throw error;
-		if (isUnavailableScmInstallationError(error)) return "unavailable";
-		throw error;
-	}
-}
-function isUnavailableScmInstallationError(error) {
-	if (!(error instanceof CliError) || error.code !== "REPO_CONNECTION_FAILED") return false;
-	return error.meta.status === 404 || error.meta.status === 422;
-}
-async function createGitHubInstallIntent(api, workspaceId, signal) {
-	const { data, error, response } = await api.POST("/v1/scm-installations/install-intents", {
-		body: {
-			provider: "github",
-			workspaceId
-		},
-		signal
-	});
-	if (error || !data) throw repoConnectionApiError("Failed to create GitHub App installation link", response, error);
-	return data.data.installUrl;
-}
-async function openInstallUrlIfInteractive(context, installUrl) {
-	if (!canPrompt(context)) return false;
-	try {
-		context.runtime.signal.throwIfAborted();
-		await open(installUrl);
-		context.runtime.signal.throwIfAborted();
-		return true;
-	} catch (error) {
-		if (context.runtime.signal.aborted) throw error;
-		return false;
-	}
-}
-async function readFirstSourceRepository(api, projectId, signal) {
-	const { data, error, response } = await api.GET("/v1/source-repositories", {
-		params: { query: {
-			projectId,
-			limit: 1
-		} },
-		signal
-	});
-	if (error || !data) throw repoConnectionApiError("Failed to inspect GitHub repository connection", response, error);
-	return data.data[0] ?? null;
-}
-function toRepositoryConnection(record) {
-	const [owner = "", name = ""] = record.repoFullName.split("/");
-	return {
-		id: record.id,
-		provider: "github",
-		repoId: record.repoId,
-		repository: {
-			owner,
-			name,
-			fullName: record.repoFullName,
-			url: `https://github.com/${record.repoFullName}`
-		},
-		defaultBranch: record.defaultBranch,
-		isPrivate: record.isPrivate,
-		status: record.status,
-		installation: {
-			id: record.installationId,
-			status: "connected"
-		},
-		automation: {
-			branches: record.status === "active",
-			pullRequests: false,
-			comments: false
-		},
-		connectedAt: record.createdAt,
-		updatedAt: record.updatedAt
-	};
-}
-function unsupportedRepositoryProviderError() {
-	return new CliError({
-		code: "REPO_PROVIDER_UNSUPPORTED",
-		domain: "project",
-		summary: "Repository provider is not supported",
-		why: "Repository connection supports GitHub repository URLs only.",
-		fix: "Pass a GitHub repository URL such as git@github.com:prisma/prisma-cli.git.",
-		exitCode: 2,
-		nextSteps: ["prisma-cli git connect git@github.com:owner/repo.git"]
-	});
-}
-function repoNotConnectedError() {
-	return new CliError({
-		code: "REPO_NOT_CONNECTED",
-		domain: "project",
-		summary: "No GitHub repository connected",
-		why: "The resolved project does not have an active GitHub repository connection.",
-		fix: "Run prisma-cli git connect before disconnecting.",
-		exitCode: 1,
-		nextSteps: ["prisma-cli git connect"]
-	});
-}
-function repoInstallationRequiredError(repository, installUrl, opened) {
-	return new CliError({
-		code: "REPO_INSTALLATION_REQUIRED",
-		domain: "project",
-		summary: "GitHub App installation required",
-		why: `The selected workspace does not have a GitHub App installation that can be used to link ${repository.fullName}.`,
-		fix: opened ? "Finish installing the GitHub App in the browser, then rerun prisma-cli git connect." : "Open the GitHub App installation URL, approve access, then rerun prisma-cli git connect.",
-		meta: {
-			repository: repository.fullName,
-			installUrl,
-			opened
-		},
-		exitCode: 1,
-		nextSteps: [installUrl, `prisma-cli git connect ${repository.url}`]
-	});
-}
-function repoNotAccessibleError(repository, installUrl, opened) {
-	return new CliError({
-		code: "REPO_NOT_ACCESSIBLE",
-		domain: "project",
-		summary: "GitHub repository is not accessible",
-		why: `The GitHub App installations connected to this workspace do not expose ${repository.fullName}.`,
-		fix: "Open the GitHub App installation URL, grant access to this repository, then rerun prisma-cli git connect.",
-		meta: {
-			repository: repository.fullName,
-			installUrl,
-			opened
-		},
-		exitCode: 1,
-		nextSteps: [installUrl, `prisma-cli git connect ${repository.url}`]
-	});
-}
-function repoAlreadyConnectedError(repositoryFullName) {
-	return new CliError({
-		code: "REPO_ALREADY_CONNECTED",
-		domain: "project",
-		summary: "Project already has a GitHub repository connected",
-		why: `The resolved project is already connected to ${repositoryFullName}.`,
-		fix: "Disconnect the existing repository before connecting a different one.",
-		meta: { repository: repositoryFullName },
-		exitCode: 1,
-		nextSteps: ["prisma-cli git disconnect"]
-	});
-}
-function repositoryFullNamesMatch(left, right) {
-	return left.toLowerCase() === right.toLowerCase();
-}
-function repoConnectionApiError(summary, response, error) {
-	const status = response?.status ?? 0;
-	const apiCode = error?.error?.code;
-	const apiMessage = error?.error?.message;
-	const apiHint = error?.error?.hint;
-	if (status === 401 || status === 403) return authRequiredError(["prisma-cli auth login"]);
-	return new CliError({
-		code: "REPO_CONNECTION_FAILED",
-		domain: "project",
-		summary,
-		why: apiMessage ?? `The Management API returned status ${status || "unknown"}.`,
-		fix: apiHint ?? repoConnectionFixForStatus(status),
-		meta: {
-			status,
-			...apiCode ? { apiCode } : {}
-		},
-		exitCode: 1,
-		nextSteps: ["prisma-cli project show"]
-	});
-}
-function repoConnectionFixForStatus(status) {
-	if (status === 404) return "Install the GitHub App for this workspace, then rerun prisma-cli git connect.";
-	if (status === 409) return "This project or repository is already linked. Disconnect the old link first, then try again.";
-	if (status === 422) return "Make sure the GitHub App installation has access to this repository.";
-	return "Re-run with --trace for the underlying API response details.";
-}
-//#endregion
-export { listRealWorkspaceProjects, runGitConnect, runGitDisconnect, runProjectCreate, runProjectLink, runProjectList, runProjectRemove, runProjectRename, runProjectShow, runProjectTransfer };