@prisma/cli 3.0.0-alpha.3 → 3.0.0-alpha.5

package/dist/controllers/project.js

@@ -1,214 +1,504 @@
-import { UnsafeConfigWriteError, readLinkedProjectId, writeLinkedProjectId } from "../adapters/config.js";
-import { CliError, authRequiredError, usageError } from "../shell/errors.js";
+import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../shell/errors.js";
+import { renderSummaryLine } from "../shell/ui.js";
 import { canPrompt } from "../shell/runtime.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
-import { createProjectUseCases, projectNotFoundError } from "../use-cases/project.js";
-import { createSelectPromptPort } from "./select-prompt-port.js";
-import { createAuthUseCases } from "../use-cases/auth.js";
+import { resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
 import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
-import { readAuthState } from "../lib/auth/auth-ops.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
+import { parseGitHubRepositoryUrl, readGitOriginRemote } from "../adapters/git.js";
+import { createProjectUseCases } from "../use-cases/project.js";
+import open from "open";
 //#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 runProjectList(context) {
+	const authState = await requireAuthenticatedAuthState(context);
+	const workspace = authState.workspace;
+	if (!workspace) throw workspaceRequiredError();
 	if (isRealMode(context)) {
-		const authState = await requireAuthenticatedAuthState(context);
 		const client = await requireComputeAuth(context.runtime.env);
-		const workspace = authState.workspace;
-		if (!client || !workspace) throw authRequiredError();
-		const { data: projectsData } = await client.GET("/v1/projects", {});
+		if (!client) throw authRequiredError();
 		return {
 			command: "project.list",
 			result: {
 				workspace,
-				linkedProjectId: await readLinkedProjectId(context.runtime.cwd),
-				projects: (projectsData?.data ?? []).filter((project) => project.workspace.id === workspace.id).map((project) => ({
-					id: project.id,
-					name: project.name
-				})).sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id))
+				projects: sortProjects(await listRealWorkspaceProjects(client, workspace)).map(toProjectSummary)
 			},
 			warnings: [],
-			nextSteps: ["prisma-cli project link"]
+			nextSteps: []
 		};
 	}
-	const authState = await requireAuthenticatedAuthState(context);
 	return {
 		command: "project.list",
 		result: await createProjectUseCases(createCliUseCaseGateways(context)).list(authState),
 		warnings: [],
-		nextSteps: ["prisma-cli project link"]
+		nextSteps: []
+	};
+}
+async function runProjectShow(context, explicitProject) {
+	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
+	if (!workspace) throw workspaceRequiredError();
+	return {
+		command: "project.show",
+		result: isRealMode(context) ? await resolveProjectShowInRealMode(context, workspace, explicitProject) : await resolveProjectShowInFixtureMode(context, workspace, explicitProject),
+		warnings: [],
+		nextSteps: []
 	};
 }
-async function runProjectShow(context) {
+async function runGitConnect(context, gitUrl, options = {}) {
+	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
+	if (!workspace) throw workspaceRequiredError();
 	if (isRealMode(context)) {
-		const linkedProjectId = await readLinkedProjectId(context.runtime.cwd);
-		if (!linkedProjectId) return {
-			command: "project.show",
-			result: {
-				linkedProjectId: null,
-				workspace: null,
-				project: null
-			},
-			warnings: [],
-			nextSteps: ["prisma-cli project link"]
-		};
-		const authState = await readAuthState(context.runtime.env);
-		if (!authState.authenticated || !authState.workspace) return {
-			command: "project.show",
+		const client = await requireComputeAuth(context.runtime.env);
+		if (!client) throw authRequiredError();
+		const target = await resolveProjectShowInRealMode(context, workspace, options.project);
+		const repository = await resolveRepositoryForConnect(context, gitUrl);
+		const api = client;
+		const existing = await readFirstSourceRepository(api, target.project.id);
+		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
+		} });
+		if (error || !data) throw repoConnectionApiError("Failed to connect GitHub repository", response, error);
+		return {
+			command: "git.connect",
 			result: {
-				linkedProjectId,
-				workspace: null,
-				project: null
+				...target,
+				repositoryConnection: toRepositoryConnection(data.data)
 			},
 			warnings: [],
-			nextSteps: ["prisma-cli auth login"]
+			nextSteps: []
 		};
-		const client = await requireComputeAuth(context.runtime.env);
-		if (!client) return {
-			command: "project.show",
+	}
+	const target = await resolveProjectShowInFixtureMode(context, workspace, options.project);
+	const repository = await resolveRepositoryForConnect(context, gitUrl);
+	const existingConnection = await context.stateStore.readRepositoryConnection(target.project.id);
+	if (existingConnection) {
+		if (repositoryFullNamesMatch(existingConnection.repository.fullName, repository.fullName)) return {
+			command: "git.connect",
 			result: {
-				linkedProjectId,
-				workspace: null,
-				project: null
+				...target,
+				repositoryConnection: existingConnection
 			},
 			warnings: [],
-			nextSteps: ["prisma-cli auth login"]
+			nextSteps: []
 		};
-		try {
-			const { data } = await client.GET("/v1/projects/{id}", { params: { path: { id: linkedProjectId } } });
-			const project = data?.data;
-			if (!project || project.workspace.id !== authState.workspace.id) return {
-				command: "project.show",
-				result: {
-					linkedProjectId,
-					workspace: null,
-					project: null
-				},
-				warnings: [],
-				nextSteps: []
-			};
-			return {
-				command: "project.show",
-				result: {
-					linkedProjectId,
-					workspace: {
-						id: project.workspace.id,
-						name: project.workspace.name
-					},
-					project: {
-						id: project.id,
-						name: project.name
-					}
-				},
-				warnings: [],
-				nextSteps: []
-			};
-		} catch {
-			return {
-				command: "project.show",
-				result: {
-					linkedProjectId,
-					workspace: null,
-					project: null
-				},
-				warnings: [],
-				nextSteps: []
-			};
-		}
+		throw repoAlreadyConnectedError(existingConnection.repository.fullName);
 	}
-	const gateways = createCliUseCaseGateways(context);
-	const authUseCases = createAuthUseCases(gateways);
-	const projectUseCases = createProjectUseCases(gateways);
-	const authState = await authUseCases.whoami();
-	const result = await projectUseCases.show(authState);
+	const connection = createPendingRepositoryConnection(repository);
+	await context.stateStore.setRepositoryConnection(target.project.id, connection);
 	return {
-		command: "project.show",
-		result,
+		command: "git.connect",
+		result: {
+			...target,
+			repositoryConnection: connection
+		},
 		warnings: [],
-		nextSteps: result.linkedProjectId ? authState.authenticated ? [] : ["prisma-cli auth login"] : ["prisma-cli project link"]
+		nextSteps: []
 	};
 }
-async function runProjectLink(context, projectId) {
-	if (!projectId && !canPrompt(context)) throw projectSelectionRequiredError();
+async function runGitDisconnect(context, options = {}) {
+	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
+	if (!workspace) throw workspaceRequiredError();
 	if (isRealMode(context)) {
-		const authState = await requireAuthenticatedAuthState(context);
 		const client = await requireComputeAuth(context.runtime.env);
-		const workspace = authState.workspace;
-		if (!client || !workspace) throw authRequiredError();
-		let selectedProject;
-		if (projectId) try {
-			const { data } = await client.GET("/v1/projects/{id}", { params: { path: { id: projectId } } });
-			if (!data?.data || data.data.workspace.id !== workspace.id) throw projectNotFoundError(`The project "${projectId}" does not exist in workspace "${workspace.name}".`, "Run prisma-cli project list and choose a project id from the active workspace.");
-			selectedProject = data.data;
-		} catch (error) {
-			if (error instanceof CliError) throw error;
-			throw projectNotFoundError(`The project "${projectId}" does not exist in workspace "${workspace.name}".`, "Run prisma-cli project list and choose a project id from the active workspace.");
-		}
-		else {
-			const { data: projectsData } = await client.GET("/v1/projects", {});
-			const projects = (projectsData?.data ?? []).filter((project) => project.workspace.id === workspace.id).map((project) => ({
-				id: project.id,
-				name: project.name,
-				workspace: project.workspace
-			})).sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
-			if (projects.length === 0) throw projectNotFoundError(`No projects are available in workspace "${workspace.name}".`, "Use prisma-cli app deploy to create project context, or switch workspaces and try again.", []);
-			selectedProject = await createSelectPromptPort(context).select({
-				message: "Select a project",
-				choices: projects.map((project) => ({
-					label: `${project.name} (${project.id})`,
-					value: project
-				}))
-			});
-		}
-		try {
-			await writeLinkedProjectId(context.runtime.cwd, selectedProject.id);
-		} catch (error) {
-			if (error instanceof UnsafeConfigWriteError) throw usageError("Project link requires a writable Prisma config", error.message, "Update prisma.config.ts to use a recognizable project field, or remove it and rerun prisma-cli project link.", ["prisma-cli project link proj_123"], "project");
-			throw error;
-		}
+		if (!client) throw authRequiredError();
+		const target = await resolveProjectShowInRealMode(context, workspace, options.project);
+		const api = client;
+		const existing = await readFirstSourceRepository(api, target.project.id);
+		if (!existing) throw repoNotConnectedError();
+		const { error, response } = await api.DELETE("/v1/source-repositories/{id}", { params: { path: { id: existing.id } } });
+		if (error) throw repoConnectionApiError("Failed to disconnect GitHub repository", response, error);
 		return {
-			command: "project.link",
+			command: "git.disconnect",
 			result: {
-				linkedProjectId: selectedProject.id,
-				workspace: {
-					id: selectedProject.workspace.id,
-					name: selectedProject.workspace.name
-				},
-				project: {
-					id: selectedProject.id,
-					name: selectedProject.name
-				}
+				...target,
+				repositoryConnection: toRepositoryConnection(existing)
 			},
 			warnings: [],
-			nextSteps: ["prisma-cli project show", "prisma-cli app deploy"]
+			nextSteps: []
 		};
 	}
-	const projectUseCases = createProjectUseCases(createCliUseCaseGateways(context));
-	const authState = await requireAuthenticatedAuthState(context);
-	const resolvedProjectId = projectId ?? await resolveProjectIdForLink(context, authState, projectUseCases);
+	const target = await resolveProjectShowInFixtureMode(context, workspace, options.project);
+	const existingConnection = await context.stateStore.readRepositoryConnection(target.project.id);
+	if (!existingConnection) throw repoNotConnectedError();
+	await context.stateStore.clearRepositoryConnection(target.project.id);
 	return {
-		command: "project.link",
-		result: await projectUseCases.link(authState, resolvedProjectId),
+		command: "git.disconnect",
+		result: {
+			...target,
+			repositoryConnection: existingConnection
+		},
 		warnings: [],
-		nextSteps: ["prisma-cli project show", "prisma-cli app deploy"]
+		nextSteps: []
 	};
 }
-async function resolveProjectIdForLink(context, authState, projectUseCases) {
-	if (!authState.workspace) throw projectSelectionRequiredError();
-	const projects = await projectUseCases.listProjectsForWorkspace(authState.workspace.id);
-	if (projects.length === 0) throw projectNotFoundError(`No projects are available in workspace "${authState.workspace.name}".`, "Use prisma-cli app deploy to create project context, or switch workspaces and try again.", []);
-	return (await createSelectPromptPort(context).select({
-		message: "Select a project",
-		choices: projects.map((project) => ({
-			label: `${project.name} (${project.id})`,
-			value: project
-		}))
-	})).id;
-}
-function projectSelectionRequiredError() {
-	return usageError("Project link requires a project target in non-interactive mode", "This command cannot prompt for project selection in the current mode.", "Re-run prisma-cli project link in a TTY, or pass a project id explicitly.", ["prisma-cli project list"], "project");
+async function resolveProjectShowInRealMode(context, workspace, explicitProject) {
+	const client = await requireComputeAuth(context.runtime.env);
+	if (!client) throw authRequiredError();
+	return resolveProjectTarget({
+		context,
+		workspace,
+		explicitProject,
+		listProjects: () => listRealWorkspaceProjects(client, workspace),
+		remember: false
+	});
+}
+async function resolveProjectShowInFixtureMode(context, workspace, explicitProject) {
+	return resolveProjectTarget({
+		context,
+		workspace,
+		explicitProject,
+		listProjects: async () => listFixtureWorkspaceProjects(context, workspace),
+		remember: false
+	});
+}
+async function listRealWorkspaceProjects(client, workspace) {
+	const { data } = await client.GET("/v1/projects", {});
+	return sortProjects((data?.data ?? []).filter((project) => project.workspace.id === workspace.id).map((project) => ({
+		id: project.id,
+		name: project.name,
+		slug: "slug" in project && typeof project.slug === "string" ? project.slug : null,
+		workspace: {
+			id: project.workspace.id,
+			name: project.workspace.name
+		}
+	})));
+}
+function listFixtureWorkspaceProjects(context, workspace) {
+	return sortProjects(context.api.listProjectsForWorkspace(workspace.id).map((project) => ({
+		id: project.id,
+		name: project.name,
+		slug: project.slug,
+		workspace
+	})));
+}
+async function resolveRepositoryForConnect(context, gitUrl) {
+	const remoteUrl = gitUrl ?? await readGitOriginRemote(context.runtime.cwd);
+	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), repository);
+	if (lookup.match) return lookup.match;
+	const installUrl = await createGitHubInstallIntent(api, workspaceId);
+	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) {
+	let inspectableInstallationCount = 0;
+	for (const installation of installations) {
+		if (installation.provider !== "github" || installation.suspended) continue;
+		const matchedRepository = await findRepositoryInInstallationIfAvailable(api, installation.id, repository);
+		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) {
+		const lookup = await findRepositoryInInstallations(api, await listScmInstallations(api, workspaceId), repository);
+		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));
+	}
+	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) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function listScmInstallations(api, workspaceId) {
+	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 } : {}
+		} } });
+		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) {
+	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 } : {}
+			}
+		} });
+		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) {
+	try {
+		return await findRepositoryInInstallation(api, installationId, repository);
+	} catch (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) {
+	const { data, error, response } = await api.POST("/v1/scm-installations/install-intents", { body: {
+		provider: "github",
+		workspaceId
+	} });
+	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 {
+		await open(installUrl);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function readFirstSourceRepository(api, projectId) {
+	const { data, error, response } = await api.GET("/v1/source-repositories", { params: { query: {
+		projectId,
+		limit: 1
+	} } });
+	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 {
+		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.";
+}
+function toProjectSummary(project) {
+	return {
+		id: project.id,
+		name: project.name
+	};
 }
 //#endregion
-export { runProjectLink, runProjectList, runProjectShow };
+export { listRealWorkspaceProjects, runGitConnect, runGitDisconnect, runProjectList, runProjectShow };

package/dist/controllers/version.js

@@ -0,0 +1,12 @@
+import { buildVersionResult } from "../lib/version.js";
+//#region src/controllers/version.ts
+async function runVersion(context) {
+	return {
+		command: "version",
+		result: buildVersionResult(context.runtime.env, context.runtime.argv),
+		warnings: [],
+		nextSteps: []
+	};
+}
+//#endregion
+export { runVersion };