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

package/dist/lib/database/provider.js

@@ -1,6 +1,18 @@
-import { CliError } from "../../shell/errors.js";
+import { formatPrismaCliCommand } from "../../cli-command.js";
+import { CliError } from "../../errors.js";
+import "../../shell/cli-command.js";
 //#region src/lib/database/provider.ts
-function createManagementDatabaseProvider(client) {
+const SUBSCRIPTION_LOOKUP_TIMEOUT_MS = 3e3;
+function createManagementDatabaseProvider(client, options) {
+	const formatCommand = options?.formatCommand ?? ((args) => formatPrismaCliCommand(args));
+	const toDatabaseApiError = (summary, response, error, signal) => databaseApiError({
+		client,
+		workspaceId: options?.workspaceId,
+		summary,
+		response,
+		error,
+		signal
+	});
 	return {
 		async listDatabases(options) {
 			const databases = [];
@@ -14,7 +26,7 @@ function createManagementDatabaseProvider(client) {
 					} },
 					signal: options.signal
 				});
-				if (result.error || !result.data) throw databaseApiError("Failed to list databases", result.response, result.error);
+				if (result.error || !result.data) throw await toDatabaseApiError("Failed to list databases", result.response, result.error, options.signal);
 				databases.push(...result.data.data);
 				if (!result.data.pagination.hasMore || !result.data.pagination.nextCursor) break;
 				cursor = result.data.pagination.nextCursor;
@@ -26,8 +38,8 @@ function createManagementDatabaseProvider(client) {
 				params: { path: { databaseId } },
 				signal: options?.signal
 			});
-			if (result.response?.status === 404) return null;
-			if (result.error || !result.data) throw databaseApiError("Failed to show database", result.response, result.error);
+			if (result.response?.status === 404 && !isPlanLimitApiError(result.error)) return null;
+			if (result.error || !result.data) throw await toDatabaseApiError("Failed to show database", result.response, result.error, options?.signal);
 			const database = result.data.data;
 			return normalizeDatabase(database, requireDatabaseProjectId(database, options?.projectId));
 		},
@@ -42,7 +54,7 @@ function createManagementDatabaseProvider(client) {
 				},
 				signal: options.signal
 			});
-			if (result.error || !result.data) throw databaseApiError("Failed to create database", result.response, result.error);
+			if (result.error || !result.data) throw await toDatabaseApiError("Failed to create database", result.response, result.error, options.signal);
 			return normalizeCreatedDatabase(result.data.data, options.projectId);
 		},
 		async removeDatabase(databaseId, options) {
@@ -50,14 +62,14 @@ function createManagementDatabaseProvider(client) {
 				params: { path: { databaseId } },
 				signal: options?.signal
 			});
-			if (result.error) throw databaseApiError("Failed to remove database", result.response, result.error);
+			if (result.error) throw await toDatabaseApiError("Failed to remove database", result.response, result.error, options?.signal);
 		},
 		async listConnections(databaseId, options) {
 			const result = await client.GET("/v1/databases/{databaseId}/connections", {
 				params: { path: { databaseId } },
 				signal: options?.signal
 			});
-			if (result.error || !result.data) throw databaseApiError("Failed to list database connections", result.response, result.error);
+			if (result.error || !result.data) throw await toDatabaseApiError("Failed to list database connections", result.response, result.error, options?.signal);
 			return result.data.data.map((connection) => normalizeConnection(connection, databaseId));
 		},
 		async createConnection(options) {
@@ -66,7 +78,7 @@ function createManagementDatabaseProvider(client) {
 				body: { name: options.name },
 				signal: options.signal
 			});
-			if (result.error || !result.data) throw databaseApiError("Failed to create database connection", result.response, result.error);
+			if (result.error || !result.data) throw await toDatabaseApiError("Failed to create database connection", result.response, result.error, options.signal);
 			return normalizeCreatedConnection(result.data.data, options.databaseId);
 		},
 		async removeConnection(connectionId, options) {
@@ -74,7 +86,56 @@ function createManagementDatabaseProvider(client) {
 				params: { path: { id: connectionId } },
 				signal: options?.signal
 			});
-			if (result.error) throw databaseApiError("Failed to remove database connection", result.response, result.error);
+			if (result.error) throw await toDatabaseApiError("Failed to remove database connection", result.response, result.error, options?.signal);
+		},
+		async getUsage(databaseId, options) {
+			const result = await client.GET("/v1/databases/{databaseId}/usage", {
+				params: {
+					path: { databaseId },
+					query: {
+						...options?.from ? { startDate: options.from } : {},
+						...options?.to ? { endDate: options.to } : {}
+					}
+				},
+				signal: options?.signal
+			});
+			if (result.error || !result.data) throw await toDatabaseApiError("Failed to fetch database usage", result.response, result.error, options?.signal);
+			return normalizeUsage(result.data);
+		},
+		async listBackups(databaseId, options) {
+			const result = await client.GET("/v1/databases/{databaseId}/backups", {
+				params: {
+					path: { databaseId },
+					query: { ...options?.limit !== void 0 ? { limit: options.limit } : {} }
+				},
+				signal: options?.signal
+			});
+			if (result.response?.status === 422 && !isPlanLimitApiError(result.error)) throw backupsUnsupportedError(databaseId, result.error);
+			if (result.error || !result.data) throw await toDatabaseApiError("Failed to list database backups", result.response, result.error, options?.signal);
+			return normalizeBackupList(result.data);
+		},
+		async restoreDatabase(options) {
+			const result = await client.POST("/v1/databases/{targetDatabaseId}/restore", {
+				params: { path: { targetDatabaseId: options.targetDatabaseId } },
+				body: { source: {
+					type: "backup",
+					databaseId: options.sourceDatabaseId,
+					backupId: options.backupId
+				} },
+				signal: options.signal
+			});
+			if (result.response?.status === 409 && !isPlanLimitApiError(result.error)) throw restoreConflictError(options.targetDatabaseId, result.error, formatCommand);
+			if (result.response?.status === 404 && !isPlanLimitApiError(result.error)) throw restoreBackupNotFoundError(options, result.error, formatCommand);
+			if (result.error || !result.data) throw await toDatabaseApiError("Failed to restore database", result.response, result.error, options.signal);
+			return normalizeDatabase(result.data.data, options.projectId);
+		},
+		async rotateConnection(connectionId, options) {
+			const result = await client.POST("/v1/connections/{id}/rotate", {
+				params: { path: { id: connectionId } },
+				signal: options?.signal
+			});
+			if (result.error || !result.data) throw await toDatabaseApiError("Failed to rotate database connection", result.response, result.error, options?.signal);
+			return normalizeRotatedConnection(result.data.data);
 		}
 	};
 }
@@ -151,17 +212,174 @@ function requireDatabaseProjectId(database, fallbackProjectId) {
 function extractConnectionString(connection) {
 	return connection.endpoints?.pooled?.connectionString ?? connection.connectionString ?? connection.endpoints?.direct?.connectionString ?? connection.endpoints?.accelerate?.connectionString ?? null;
 }
-function databaseApiError(summary, response, error) {
-	const status = response?.status ?? 0;
+/** Absence is carried, not filled in. A `0` here reached the card, the
+*  stdout lane and the json record as though the API had measured it, and
+*  "you used nothing" is the answer a user acts on. The unit is the same
+*  problem an order of magnitude worse: `GiB` was a guess, and a value the
+*  API denominates in bytes would print against it unchanged. */
+function normalizeUsageMetric(metric) {
+	return {
+		used: metric?.used ?? null,
+		unit: metric?.unit ?? null
+	};
+}
+function normalizeUsage(usage) {
+	return {
+		period: {
+			start: usage.period?.start ?? null,
+			end: usage.period?.end ?? null
+		},
+		metrics: {
+			operations: normalizeUsageMetric(usage.metrics?.operations),
+			storage: normalizeUsageMetric(usage.metrics?.storage)
+		},
+		generatedAt: usage.generatedAt ?? null
+	};
+}
+function normalizeBackupList(body) {
+	return {
+		backups: (body.data ?? []).map((backup) => ({
+			id: backup.id,
+			backupType: backup.backupType ?? "",
+			status: backup.status ?? "",
+			size: backup.size ?? null,
+			createdAt: backup.createdAt ?? ""
+		})),
+		retentionDays: body.meta?.backupRetentionDays ?? null,
+		hasMore: body.pagination?.hasMore ?? false
+	};
+}
+function normalizeRotatedConnection(connection) {
+	const connectionString = extractConnectionString(connection);
+	if (!connectionString) throw new CliError({
+		code: "DATABASE_CONNECTION_STRING_MISSING",
+		domain: "database",
+		summary: "Rotated connection did not return a connection string",
+		why: "Rotated connection strings are one-time-view secrets, but the Management API did not include one in this rotate response.",
+		fix: "Re-run the rotation, or create a replacement connection and store the returned URL immediately.",
+		exitCode: 1,
+		nextSteps: []
+	});
+	const database = connection.database?.id && connection.database?.name ? {
+		id: connection.database.id,
+		name: connection.database.name
+	} : null;
+	return {
+		connection: normalizeConnection(connection, connection.database?.id ?? connection.databaseId ?? ""),
+		database,
+		connectionString
+	};
+}
+function backupsUnsupportedError(databaseId, error) {
 	return new CliError({
-		code: error?.error?.code ?? "DATABASE_API_ERROR",
+		code: "DATABASE_BACKUPS_UNSUPPORTED",
 		domain: "database",
-		summary,
-		why: error?.error?.message ?? `The Management API returned status ${status || "unknown"}.`,
-		fix: error?.error?.hint ?? "Re-run with --trace for the underlying API response details.",
+		summary: "Backups are not available for this database",
+		why: error?.error?.message ?? `The platform does not manage backups for database "${databaseId}", for example because it is a remote/BYO database.`,
+		fix: "Use your own backup tooling for externally managed databases.",
+		exitCode: 1,
+		nextSteps: []
+	});
+}
+function restoreBackupNotFoundError(options, error, formatCommand) {
+	const listCommand = formatCommand([
+		"database",
+		"backup",
+		"list",
+		options.sourceDatabaseId
+	]);
+	return new CliError({
+		code: "DATABASE_BACKUP_NOT_FOUND",
+		domain: "database",
+		summary: "Database backup not found",
+		why: error?.error?.message ?? `No backup matched "${options.backupId}" for database "${options.sourceDatabaseId}".`,
+		fix: `Pass a backup id from ${listCommand}.`,
+		exitCode: 1,
+		nextSteps: [listCommand]
+	});
+}
+function restoreConflictError(targetDatabaseId, error, formatCommand) {
+	return new CliError({
+		code: "DATABASE_RESTORE_CONFLICT",
+		domain: "database",
+		summary: "Database cannot be restored right now",
+		why: error?.error?.message ?? `Database "${targetDatabaseId}" is provisioning or already recovering.`,
+		fix: "Wait for the database to become ready, then retry the restore.",
+		exitCode: 1,
+		nextSteps: [formatCommand([
+			"database",
+			"show",
+			targetDatabaseId
+		])]
+	});
+}
+async function databaseApiError(options) {
+	if (isPlanLimitApiError(options.error)) return planLimitReachedError(options);
+	const status = options.response?.status ?? 0;
+	return new CliError({
+		code: options.error?.error?.code ?? "DATABASE_API_ERROR",
+		domain: "database",
+		summary: options.summary,
+		why: options.error?.error?.message ?? `The Management API returned status ${status || "unknown"}.`,
+		fix: options.error?.error?.hint ?? "Re-run with --trace for the underlying API response details.",
 		exitCode: 1,
 		nextSteps: []
 	});
 }
+async function planLimitReachedError(options) {
+	const subscription = options.workspaceId ? await readWorkspaceSubscription(options.client, options.workspaceId, options.signal) : null;
+	const workspaceLine = options.workspaceId ? `Workspace: ${options.workspaceId}` : "Workspace: unavailable";
+	const planName = subscription?.planName || null;
+	const usageBlocked = subscription?.usageBlocked ?? null;
+	const upgradeUrl = subscription?.upgradeUrl || null;
+	const recoveryLines = [...planName ? [`Current plan: ${planName}`] : [], upgradeUrl ? `Upgrade: ${upgradeUrl}` : "Upgrade: Open Prisma Console and upgrade the affected workspace plan."];
+	return new CliError({
+		code: "PLAN_LIMIT_REACHED",
+		domain: "database",
+		summary: "Workspace plan limit reached",
+		why: "Database operations are blocked because this workspace has used the operations included in its plan. This is a workspace plan limit, not a Prisma outage.",
+		fix: upgradeUrl ? `Upgrade the workspace plan at ${upgradeUrl}.` : "Open Prisma Console and upgrade the affected workspace plan.",
+		meta: {
+			workspaceId: options.workspaceId ?? null,
+			blockedFeature: null,
+			planName,
+			usageBlocked,
+			upgradeUrl
+		},
+		exitCode: 1,
+		nextSteps: [],
+		humanLines: [
+			"Workspace plan limit reached [PLAN_LIMIT_REACHED]",
+			"",
+			"Database operations are blocked because this workspace has used the operations included in its plan. This is a workspace plan limit, not a Prisma outage.",
+			"",
+			workspaceLine,
+			...recoveryLines
+		]
+	});
+}
+function isPlanLimitApiError(error) {
+	return error?.error?.code === "planLimitReached";
+}
+async function readWorkspaceSubscription(client, workspaceId, signal) {
+	signal?.throwIfAborted();
+	const timeoutController = new AbortController();
+	const timeout = setTimeout(() => timeoutController.abort(), SUBSCRIPTION_LOOKUP_TIMEOUT_MS);
+	const requestSignal = signal ? AbortSignal.any([signal, timeoutController.signal]) : timeoutController.signal;
+	try {
+		const result = await client.GET("/v1/workspaces/{id}/subscription", {
+			params: { path: { id: workspaceId } },
+			signal: requestSignal
+		});
+		signal?.throwIfAborted();
+		if (result.error) return null;
+		return result.data?.data ?? null;
+	} catch {
+		signal?.throwIfAborted();
+		return null;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
 //#endregion
-export { createManagementDatabaseProvider, normalizeConnection, normalizeDatabase };
+export { createManagementDatabaseProvider };

package/dist/lib/diagnostics.js

@@ -1,5 +1,6 @@
 import { resolveLocalStateFilePath } from "../adapters/local-state.js";
-import { resolveStateDir } from "../shell/runtime.js";
+import { resolveStateDir } from "../state-dir.js";
+import "../shell/runtime.js";
 import { readLocalGitState } from "./git/local-status.js";
 //#region src/lib/diagnostics.ts
 async function collectCommandDiagnostics(context, options = {}) {

package/dist/lib/feedback.js

@@ -0,0 +1,15 @@
+//#region src/lib/feedback.ts
+const FEEDBACK_TIMEOUT_MS = 3e3;
+const TIMEOUT_DETAIL = `The feedback service did not answer within ${FEEDBACK_TIMEOUT_MS / 1e3} seconds.`;
+function isTimeout(error) {
+	return error instanceof Error && error.name === "TimeoutError";
+}
+function unreachableDetail(error) {
+	if (isTimeout(error)) return TIMEOUT_DETAIL;
+	return `The feedback service could not be reached${error instanceof Error && error.cause instanceof Error ? ` (${error.cause.message})` : ""}.`;
+}
+function unreadableBodyDetail(error) {
+	return isTimeout(error) ? TIMEOUT_DETAIL : "The feedback service response could not be read.";
+}
+//#endregion
+export { FEEDBACK_TIMEOUT_MS, unreachableDetail, unreadableBodyDetail };

package/dist/lib/git/local-branch.js

@@ -1,5 +1,5 @@
-import { access, readFile } from "node:fs/promises";
 import path from "node:path";
+import { access, readFile } from "node:fs/promises";
 //#region src/lib/git/local-branch.ts
 /**
 * Resolves the checked-out branch the way git does: the nearest `.git`

package/dist/lib/project/interactive-setup.js

@@ -1,4 +1,4 @@
-import { usageError } from "../../shell/errors.js";
+import { usageError } from "../../errors.js";
 import { selectPrompt, textPrompt } from "../../shell/prompt.js";
 import { inferTargetName, sortProjects } from "./resolution.js";
 import { toProjectSummary, validateProjectSetupNameText } from "./setup.js";
@@ -12,6 +12,10 @@ async function promptForProjectSetupChoice(options) {
 		output: options.context.runtime.stderr,
 		message: "Which Project should this directory use?",
 		choices: [
+			{
+				label: "+ Create a new Project",
+				value: { kind: "create" }
+			},
 			...sortedProjects.map((project) => ({
 				label: duplicateNames.has(project.name) ? `${project.name} (${project.id})` : project.name,
 				value: {
@@ -19,10 +23,6 @@ async function promptForProjectSetupChoice(options) {
 					project
 				}
 			})),
-			{
-				label: "Create a new Project",
-				value: { kind: "create" }
-			},
 			{
 				label: "Cancel",
 				value: { kind: "cancel" }
@@ -40,6 +40,7 @@ async function promptForProjectSetupChoice(options) {
 	const rawName = await textPrompt({
 		input: options.context.runtime.stdin,
 		output: options.context.runtime.stderr,
+		signal: options.context.runtime.signal,
 		message: "Project name",
 		placeholder: suggestedName.name,
 		validate: (value) => validateProjectSetupNameText(value, suggestedName.name)

package/dist/lib/project/local-pin.js

@@ -1,5 +1,5 @@
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { Result, TaggedError, UnhandledException } from "better-result";
 //#region src/lib/project/local-pin.ts
 const LOCAL_RESOLUTION_PIN_RELATIVE_PATH = ".prisma/local.json";

package/dist/lib/project/provider.js

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

package/dist/lib/project/resolution.js

@@ -1,8 +1,9 @@
-import { CliError } from "../../shell/errors.js";
+import { formatCommandArgument } from "../../command-arguments.js";
+import { CliError } from "../../errors.js";
+import { sameWorkspaceId } from "../workspace-id.js";
 import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin } from "./local-pin.js";
-import { formatCommandArgument } from "../../shell/command-arguments.js";
-import { readFile } from "node:fs/promises";
 import path from "node:path";
+import { readFile } from "node:fs/promises";
 import { Result, TaggedError, matchError } from "better-result";
 //#region src/lib/project/resolution.ts
 var ProjectNotFoundError = class extends TaggedError("ProjectNotFoundError")() {
@@ -283,8 +284,9 @@ async function inferTargetName(cwd, signal) {
 		source: "directory-name"
 	};
 }
+const INFERRED_TARGET_NAME = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 function isValidInferredTargetName(value) {
-	return /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(value);
+	return INFERRED_TARGET_NAME.test(value);
 }
 function sortProjects(projects) {
 	return projects.slice().sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
@@ -321,7 +323,7 @@ async function resolveBoundProjectTarget(options, projects, settings) {
 	const localPin = settings.localPin;
 	if (!localPin) return Result.ok(null);
 	if (localPin.kind === "present") {
-		if (localPin.pin.workspaceId !== options.workspace.id) return Result.err(new LocalProjectWorkspaceMismatchError({
+		if (!sameWorkspaceId(localPin.pin.workspaceId, options.workspace.id)) return Result.err(new LocalProjectWorkspaceMismatchError({
 			pinnedWorkspaceId: localPin.pin.workspaceId,
 			pinnedProjectId: localPin.pin.projectId,
 			activeWorkspace: options.workspace
@@ -334,7 +336,7 @@ async function resolveBoundProjectTarget(options, projects, settings) {
 		}));
 	}
 	const platformMapping = await resolveDurablePlatformMapping();
-	if (platformMapping && platformMapping.workspace.id === options.workspace.id) return Result.ok(resolvedTarget(options.workspace, platformMapping, "platform-mapping", {
+	if (platformMapping && sameWorkspaceId(platformMapping.workspace.id, options.workspace.id)) return Result.ok(resolvedTarget(options.workspace, platformMapping, "platform-mapping", {
 		targetName: platformMapping.name,
 		targetNameSource: "platform-mapping"
 	}));
@@ -345,7 +347,7 @@ async function readImplicitLocalPin(options, settings) {
 	const localPinResult = await readLocalResolutionPin(options.projectDir ?? options.context.runtime.cwd, options.context.runtime.signal);
 	if (localPinResult.isErr()) return Result.err(localPinReadErrorToProjectError(localPinResult.error));
 	const localPin = localPinResult.value;
-	if (localPin.kind === "present" && localPin.pin.workspaceId !== options.workspace.id) return Result.err(new LocalProjectWorkspaceMismatchError({
+	if (localPin.kind === "present" && !sameWorkspaceId(localPin.pin.workspaceId, options.workspace.id)) return Result.err(new LocalProjectWorkspaceMismatchError({
 		pinnedWorkspaceId: localPin.pin.workspaceId,
 		pinnedProjectId: localPin.pin.projectId,
 		activeWorkspace: options.workspace
@@ -379,7 +381,8 @@ function toProjectSummary(project) {
 	return {
 		id: project.id,
 		name: project.name,
-		...project.url ? { url: project.url } : {}
+		...project.url ? { url: project.url } : {},
+		...project.defaultRegion != null ? { defaultRegion: project.defaultRegion } : {}
 	};
 }
 //#endregion

package/dist/lib/project/setup.js

@@ -1,7 +1,6 @@
-import { CliError, usageError } from "../../shell/errors.js";
+import { CliError, usageError } from "../../errors.js";
 import { shortenHomePath } from "../fs/home-path.js";
 import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, ensureLocalResolutionPinGitignore, writeLocalResolutionPin } from "./local-pin.js";
-import "../../shell/command-arguments.js";
 import { projectAmbiguousError, projectNotFoundError } from "./resolution.js";
 import path from "node:path";
 import { Result, matchError } from "better-result";
@@ -15,8 +14,9 @@ function validateProjectSetupNameText(value, fallback) {
 }
 function resolveProjectForSetup(projectRef, projects, workspace) {
 	const matches = projects.filter((project) => project.id === projectRef || project.name === projectRef);
-	if (matches.length === 1) return matches[0];
 	if (matches.length > 1) throw projectAmbiguousError(projectRef, matches);
+	const match = matches[0];
+	if (match !== void 0) return match;
 	throw projectNotFoundError(projectRef, workspace);
 }
 async function bindProjectToDirectory(context, workspace, project, action, directory = context.runtime.cwd) {
@@ -82,7 +82,8 @@ function toProjectSummary(project) {
 	return {
 		id: project.id,
 		name: project.name,
-		...project.url ? { url: project.url } : {}
+		...project.url ? { url: project.url } : {},
+		...project.defaultRegion != null ? { defaultRegion: project.defaultRegion } : {}
 	};
 }
 function projectSetupNameRequiredError(command) {
@@ -111,18 +112,20 @@ function projectCreateFailedError(error, projectName, workspace, options) {
 		nextSteps: options.nextSteps
 	});
 }
+const PATH_SEPARATORS = /[\\/]/;
 function formatSetupDirectory(directory, context) {
 	if (path.resolve(directory) !== path.resolve(context.runtime.cwd)) return shortenHomePath(directory, context.runtime.env);
-	const basename = directory.split(/[\\/]/).filter(Boolean).pop();
+	const basename = directory.split(PATH_SEPARATORS).filter(Boolean).pop();
 	return basename ? `./${basename}` : ".";
 }
+const HTTP_STATUS_IN_MESSAGE = /\(HTTP (\d{3})\)/;
 function extractHttpStatus(error) {
 	if (!error || typeof error !== "object") return null;
 	const candidate = error;
 	if (typeof candidate.statusCode === "number") return candidate.statusCode;
 	if (typeof candidate.status === "number") return candidate.status;
 	if (typeof candidate.message === "string") {
-		const match = /\(HTTP (\d{3})\)/.exec(candidate.message);
+		const match = HTTP_STATUS_IN_MESSAGE.exec(candidate.message);
 		if (match) return Number.parseInt(match[1], 10);
 	}
 	return null;

package/dist/lib/version.js

@@ -1,4 +1,5 @@
-import { CliError } from "../shell/errors.js";
+import { CliError } from "../errors.js";
+import { CLI_NAME } from "../cli-name.js";
 import { createRequire } from "node:module";
 import process from "node:process";
 //#region src/lib/version.ts
@@ -23,7 +24,7 @@ function getCliVersion() {
 	return pkg.version;
 }
 function getCliName() {
-	return "prisma-cli";
+	return CLI_NAME;
 }
 function detectInvocation(env, argv) {
 	if (env.npm_config_user_agent?.startsWith("bun")) return "bunx";

package/dist/lib/workspace-id.js

@@ -0,0 +1,18 @@
+//#region src/lib/workspace-id.ts
+/**
+* A workspace reaches the CLI under two ids for the same workspace: a
+* credential's `workspace_id` claim carries the bare id, while the
+* management API and anything derived from it carry the same id behind
+* a `wksp_` prefix. Comparing the two forms directly silently matches
+* nothing, so every comparison between workspace ids of different
+* origin goes through here.
+*/
+const WORKSPACE_ID_PREFIX = "wksp_";
+function stripWorkspacePrefix(value) {
+	return value.startsWith(WORKSPACE_ID_PREFIX) ? value.slice(5) : value;
+}
+function sameWorkspaceId(left, right) {
+	return stripWorkspacePrefix(left) === stripWorkspacePrefix(right);
+}
+//#endregion
+export { sameWorkspaceId };

package/dist/payload-B88Qvzxk-CrtTXSOe.js

@@ -0,0 +1,34 @@
+//#region ../cli-telemetry/dist/payload-B88Qvzxk.js
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.length > 0;
+}
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+/**
+* Runtime validation for {@link ParentToSenderPayload}. The child sender
+* uses this before `postEvent` so a payload missing a required field
+* cannot silently produce a degraded telemetry event downstream.
+*
+* Same semantics as the ORM CLI's arktype schema (this repo carries no
+* arktype dependency, so the checks are spelled out): required scalars
+* must be non-empty strings; the optional `databaseTarget` override is
+* a `string` when present (no `null` — see the type's doc-block); the
+* string array is validated element-by-element. Size caps are enforced
+* by the backend, not here — IPC is structured-cloned and the
+* parent/child agree on the schema by version-coupling.
+*/
+function isParentToSenderPayload(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const record = value;
+	if (!isNonEmptyString(record.installationId)) return false;
+	if (!isNonEmptyString(record.version)) return false;
+	if (!isNonEmptyString(record.command)) return false;
+	if (!isStringArray(record.flags)) return false;
+	if (!isNonEmptyString(record.projectRoot)) return false;
+	if (!isNonEmptyString(record.endpoint)) return false;
+	if ("databaseTarget" in record && typeof record.databaseTarget !== "string") return false;
+	return true;
+}
+//#endregion
+export { isParentToSenderPayload as t };