@prisma/cli 3.0.0-dev.75.1 → 3.0.0-dev.78.1

package/dist/controllers/app-env.js

@@ -2,7 +2,7 @@ import { CliError, authRequiredError, usageError, workspaceRequiredError } from
 import { requireComputeAuth } from "../lib/auth/guard.js";
 import { formatScopeLabel, parseKeyValuePositional, resolveEnvScope } from "../lib/app/env-config.js";
 import { readEnvFileAssignments } from "../lib/app/env-file.js";
-import { resolveProjectTarget } from "../lib/project/resolution.js";
+import { projectResolutionErrorToCliError, resolveProjectTarget } from "../lib/project/resolution.js";
 import { readLocalGitBranch } from "../lib/git/local-branch.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
 import { listRealWorkspaceProjects } from "./project.js";
@@ -205,13 +205,15 @@ async function requireClientAndProject(context, explicitProject, commandName) {
 	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 	if (!client) throw authRequiredError(["prisma-cli auth login"]);
 	if (!authState.workspace) throw workspaceRequiredError();
-	const target = await resolveProjectTarget({
+	const targetResult = await resolveProjectTarget({
 		context,
 		workspace: authState.workspace,
 		explicitProject,
 		listProjects: () => listRealWorkspaceProjects(client, authState.workspace, context.runtime.signal),
 		commandName
 	});
+	if (targetResult.isErr()) throw projectResolutionErrorToCliError(targetResult.error);
+	const target = targetResult.value;
 	return {
 		client,
 		projectId: target.project.id,

package/dist/controllers/app.js

@@ -13,8 +13,8 @@ import { readBunPackageEntrypoint, readBunPackageJson } from "../lib/app/bun-pro
 import { DEFAULT_LOCAL_DEV_PORT, resolveLocalBuildType, runLocalApp } from "../lib/app/local-dev.js";
 import { formatCommandArgument } from "../shell/command-arguments.js";
 import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin } from "../lib/project/local-pin.js";
-import { buildProjectSetupNextActions, inferTargetName, projectNotFoundError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
-import { bindProjectToDirectory, projectCreateFailedError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
+import { buildProjectSetupNextActions, inferTargetName, projectNotFoundError, projectResolutionErrorToCliError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
+import { bindProjectToDirectory, projectCreateFailedError, projectDirectoryBindingErrorToCliError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
 import { promptForProjectSetupChoice } from "../lib/project/interactive-setup.js";
 import { readLocalGitBranch } from "../lib/git/local-branch.js";
 import { resolveOrCreatePreviewBuildSettings } from "../lib/app/preview-build-settings.js";
@@ -131,8 +131,10 @@ async function runAppDeploy(context, appName, options) {
 	let localPinResult;
 	if (target.localPinAction) {
 		const setupResult = await bindProjectToDirectory(context, target.workspace, target.project, target.localPinAction);
-		localPinResult = setupResult.localPin;
-		maybeRenderProjectLinked(context, setupResult.directory, setupResult.project.name, setupResult.localPin.path);
+		if (setupResult.isErr()) throw projectDirectoryBindingErrorToCliError(setupResult.error);
+		const projectSetup = setupResult.value;
+		localPinResult = projectSetup.localPin;
+		maybeRenderProjectLinked(context, projectSetup.directory, projectSetup.project.name, projectSetup.localPin.path);
 	}
 	let framework = await resolveDeployFramework(context, {
 		requestedFramework: options?.framework,
@@ -1356,7 +1358,7 @@ async function requireProviderAndDeployProjectContext(context, explicitProject,
 async function resolveProjectContext(context, client, explicitProject, options) {
 	const authState = await requireAuthenticatedAuthState(context);
 	if (!authState.workspace) throw workspaceRequiredError();
-	const resolved = await resolveProjectTarget({
+	const resolvedResult = await resolveProjectTarget({
 		context,
 		workspace: authState.workspace,
 		explicitProject,
@@ -1364,6 +1366,8 @@ async function resolveProjectContext(context, client, explicitProject, options)
 		listProjects: () => listRealWorkspaceProjects(client, authState.workspace, context.runtime.signal),
 		commandName: options?.commandName
 	});
+	if (resolvedResult.isErr()) throw projectResolutionErrorToCliError(resolvedResult.error);
+	const resolved = resolvedResult.value;
 	const branch = options?.branch ?? await resolveDeployBranch(context, void 0);
 	return {
 		...resolved,

package/dist/controllers/branch.js

@@ -1,8 +1,7 @@
 import { CliError, authRequiredError, workspaceRequiredError } from "../shell/errors.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
-import { resolveProjectTarget } from "../lib/project/resolution.js";
+import { projectResolutionErrorToCliError, resolveProjectTarget } from "../lib/project/resolution.js";
 import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
-import { createSelectPromptPort } from "./select-prompt-port.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
 import { listRealWorkspaceProjects } from "./project.js";
 import { createBranchUseCases } from "../use-cases/branch.js";
@@ -30,13 +29,13 @@ async function listRealBranches(context) {
 	if (!client) throw authRequiredError(["prisma-cli auth login"]);
 	const workspace = authState.workspace;
 	if (!workspace) throw workspaceRequiredError();
-	const target = await resolveProjectTarget({
+	const targetResult = await resolveProjectTarget({
 		context,
 		workspace,
-		listProjects: () => listRealWorkspaceProjects(client, workspace, context.runtime.signal),
-		prompt: createSelectPromptPort(context),
-		remember: true
+		listProjects: () => listRealWorkspaceProjects(client, workspace, context.runtime.signal)
 	});
+	if (targetResult.isErr()) throw projectResolutionErrorToCliError(targetResult.error);
+	const target = targetResult.value;
 	const branches = await listBranches(client, target.project.id, context.runtime.signal);
 	return {
 		projectId: target.project.id,

package/dist/controllers/database.js

@@ -1,6 +1,6 @@
 import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../shell/errors.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
-import { resolveProjectTarget } from "../lib/project/resolution.js";
+import { projectResolutionErrorToCliError, resolveProjectTarget } from "../lib/project/resolution.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
 import { listFixtureWorkspaceProjects, listRealWorkspaceProjects } from "./project.js";
 import { createManagementDatabaseProvider, normalizeConnection, normalizeDatabase } from "../lib/database/provider.js";
@@ -155,28 +155,30 @@ async function requireDatabaseContext(context, flags, commandName) {
 	if (isRealMode(context)) {
 		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 		if (!client) throw authRequiredError();
-		const target = await resolveProjectTarget({
+		const targetResult = await resolveProjectTarget({
 			context,
 			workspace,
 			explicitProject: flags.projectRef,
 			listProjects: () => listRealWorkspaceProjects(client, workspace, context.runtime.signal),
 			commandName
 		});
+		if (targetResult.isErr()) throw projectResolutionErrorToCliError(targetResult.error);
 		return {
 			provider: createManagementDatabaseProvider(client),
-			target
+			target: targetResult.value
 		};
 	}
-	const target = await resolveProjectTarget({
+	const targetResult = await resolveProjectTarget({
 		context,
 		workspace,
 		explicitProject: flags.projectRef,
 		listProjects: async () => listFixtureWorkspaceProjects(context, workspace),
 		commandName
 	});
+	if (targetResult.isErr()) throw projectResolutionErrorToCliError(targetResult.error);
 	return {
 		provider: createFixtureDatabaseProvider(context),
-		target
+		target: targetResult.value
 	};
 }
 async function requireDatabaseProviderOnly(context) {

package/dist/controllers/project.js

@@ -4,8 +4,8 @@ import { canPrompt } from "../shell/runtime.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
 import { formatCommandArgument } from "../shell/command-arguments.js";
 import { readLocalResolutionPin } from "../lib/project/local-pin.js";
-import { buildProjectSetupNextActions, inferTargetName, inspectProjectBinding, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
-import { bindProjectToDirectory, isValidProjectSetupName, projectCreateFailedError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.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 { createPreviewAppProvider } from "../lib/app/preview-provider.js";
 import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
@@ -116,12 +116,14 @@ async function runProjectCreate(context, projectName) {
 			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");
+	if (bindResult.isErr()) throw projectDirectoryBindingErrorToCliError(bindResult.error);
 	return {
 		command: "project.create",
-		result: await bindProjectToDirectory(context, workspace, {
-			id: created.id,
-			name: created.name
-		}, "created"),
+		result: bindResult.value,
 		warnings: [],
 		nextSteps: ["prisma-cli app deploy"]
 	};
@@ -138,7 +140,7 @@ async function runProjectLink(context, projectRef) {
 		projects = await listRealWorkspaceProjects(client, workspace, context.runtime.signal);
 	} else projects = listFixtureWorkspaceProjects(context, workspace);
 	let result;
-	if (projectRef?.trim()) result = await bindProjectToDirectory(context, workspace, toProjectSummary(resolveProjectForSetup(projectRef.trim(), projects, workspace)), "linked");
+	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 {
@@ -162,7 +164,12 @@ async function resolveInteractiveProjectLinkSetup(context, workspace, projects,
 			nextSteps: ["prisma-cli project link <id-or-name>", "prisma-cli project create <name>"]
 		}
 	});
-	return bindProjectToDirectory(context, workspace, setup.project, setup.action);
+	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({
@@ -323,42 +330,50 @@ async function runGitDisconnect(context, options = {}) {
 async function resolveProjectShowInRealMode(context, workspace, explicitProject) {
 	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 	if (!client) throw authRequiredError();
-	return inspectProjectBinding({
+	const result = await inspectProjectBinding({
 		context,
 		workspace,
 		explicitProject,
 		listProjects: () => listRealWorkspaceProjects(client, workspace, context.runtime.signal),
 		commandName: "project show"
 	});
+	if (result.isErr()) throw projectResolutionErrorToCliError(result.error);
+	return result.value;
 }
 async function resolveRequiredProjectInRealMode(context, workspace, explicitProject, commandName) {
 	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 	if (!client) throw authRequiredError();
-	return resolveProjectTarget({
+	const result = await resolveProjectTarget({
 		context,
 		workspace,
 		explicitProject,
 		listProjects: () => listRealWorkspaceProjects(client, workspace, context.runtime.signal),
 		commandName
 	});
+	if (result.isErr()) throw projectResolutionErrorToCliError(result.error);
+	return result.value;
 }
 async function resolveProjectShowInFixtureMode(context, workspace, explicitProject) {
-	return inspectProjectBinding({
+	const result = await inspectProjectBinding({
 		context,
 		workspace,
 		explicitProject,
 		listProjects: async () => listFixtureWorkspaceProjects(context, workspace),
 		commandName: "project show"
 	});
+	if (result.isErr()) throw projectResolutionErrorToCliError(result.error);
+	return result.value;
 }
 async function resolveRequiredProjectInFixtureMode(context, workspace, explicitProject, commandName) {
-	return resolveProjectTarget({
+	const result = await resolveProjectTarget({
 		context,
 		workspace,
 		explicitProject,
 		listProjects: async () => listFixtureWorkspaceProjects(context, workspace),
 		commandName
 	});
+	if (result.isErr()) throw projectResolutionErrorToCliError(result.error);
+	return result.value;
 }
 async function listRealWorkspaceProjects(client, workspace, signal) {
 	const { data } = await client.GET("/v1/projects", { signal });

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

@@ -29,6 +29,53 @@ var LocalResolutionPinReadAbortedError = class extends TaggedError("LocalResolut
 		});
 	}
 };
+var LocalResolutionPinSerializationError = class extends TaggedError("LocalResolutionPinSerializationError")() {
+	constructor(cause) {
+		super({
+			message: `Could not serialize ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH}.`,
+			cause,
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
+		});
+	}
+};
+var LocalResolutionPinWriteAbortedError = class extends TaggedError("LocalResolutionPinWriteAbortedError")() {
+	constructor(cause) {
+		super({
+			message: `Writing ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} was aborted.`,
+			cause,
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
+		});
+	}
+};
+var LocalResolutionPinWriteFailedError = class extends TaggedError("LocalResolutionPinWriteFailedError")() {
+	constructor(operation, cause) {
+		super({
+			message: `Could not write ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH}.`,
+			cause,
+			operation,
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
+		});
+	}
+};
+var LocalResolutionPinGitignoreUpdateAbortedError = class extends TaggedError("LocalResolutionPinGitignoreUpdateAbortedError")() {
+	constructor(cause) {
+		super({
+			message: "Updating .gitignore for the local Project binding was aborted.",
+			cause,
+			gitignorePath: ".gitignore"
+		});
+	}
+};
+var LocalResolutionPinGitignoreUpdateFailedError = class extends TaggedError("LocalResolutionPinGitignoreUpdateFailedError")() {
+	constructor(operation, cause) {
+		super({
+			message: "Could not update .gitignore for the local Project binding.",
+			cause,
+			operation,
+			gitignorePath: ".gitignore"
+		});
+	}
+};
 async function readLocalResolutionPin(cwd, signal) {
 	return Result.gen(async function* () {
 		yield* ensureLocalResolutionPinReadNotAborted(signal);
@@ -72,41 +119,74 @@ function parseLocalResolutionPin(raw) {
 	});
 }
 async function writeLocalResolutionPin(cwd, pin, signal) {
-	const prismaDir = path.join(cwd, ".prisma");
-	signal?.throwIfAborted();
-	await mkdir(prismaDir, { recursive: true });
-	const pinPath = path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH);
-	const tmpPath = path.join(prismaDir, `local.${process.pid}.${Date.now()}.tmp`);
-	await writeFile(tmpPath, `${JSON.stringify(pin, null, 2)}\n`, {
-		encoding: "utf8",
-		signal
+	return Result.gen(async function* () {
+		const prismaDir = path.join(cwd, ".prisma");
+		yield* ensureLocalResolutionPinWriteNotAborted(signal);
+		yield* Result.await(writeLocalResolutionPinBoundary(() => mkdir(prismaDir, { recursive: true }), "create-directory", signal));
+		const pinPath = path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH);
+		const tmpPath = path.join(prismaDir, `local.${process.pid}.${Date.now()}.tmp`);
+		const serialized = yield* serializeLocalResolutionPin(pin);
+		yield* Result.await(writeLocalResolutionPinBoundary(() => writeFile(tmpPath, serialized, {
+			encoding: "utf8",
+			signal
+		}), "write-temp-file", signal));
+		yield* ensureLocalResolutionPinWriteNotAborted(signal);
+		yield* Result.await(writeLocalResolutionPinBoundary(() => rename(tmpPath, pinPath), "rename-temp-file", signal));
+		return Result.ok(void 0);
 	});
-	signal?.throwIfAborted();
-	await rename(tmpPath, pinPath);
 }
 async function ensureLocalResolutionPinGitignore(cwd, signal) {
 	const gitignorePath = path.join(cwd, ".gitignore");
 	let existing = null;
-	signal?.throwIfAborted();
-	try {
-		existing = await readFile(gitignorePath, {
+	const notAborted = ensureLocalResolutionPinGitignoreUpdateNotAborted(signal);
+	if (notAborted.isErr()) return Result.err(notAborted.error);
+	const existingResult = await Result.tryPromise({
+		try: () => readFile(gitignorePath, {
 			encoding: "utf8",
 			signal
-		});
-	} catch (error) {
-		if (error.code !== "ENOENT") throw error;
-	}
-	if (existing === null) {
-		await writeFile(gitignorePath, ".prisma/\n", {
+		}),
+		catch: (cause) => signal?.aborted ? new LocalResolutionPinGitignoreUpdateAbortedError(cause) : new LocalResolutionPinGitignoreUpdateFailedError("read", cause)
+	});
+	if (existingResult.isErr()) if (existingResult.error instanceof LocalResolutionPinGitignoreUpdateFailedError && existingResult.error.cause.code === "ENOENT") existing = null;
+	else return Result.err(existingResult.error);
+	else existing = existingResult.value;
+	if (existing === null) return writeLocalResolutionPinGitignore(gitignorePath, ".prisma/\n", signal);
+	if (existing.split(/\r?\n/).map((line) => line.trim()).some((line) => line === ".prisma/" || line === ".prisma/local.json")) return Result.ok(void 0);
+	return writeLocalResolutionPinGitignore(gitignorePath, existing.endsWith("\n") ? `${existing}.prisma/\n` : `${existing}\n.prisma/\n`, signal);
+}
+function ensureLocalResolutionPinWriteNotAborted(signal) {
+	return Result.try({
+		try: () => signal?.throwIfAborted(),
+		catch: (cause) => new LocalResolutionPinWriteAbortedError(cause)
+	});
+}
+function serializeLocalResolutionPin(pin) {
+	return Result.try({
+		try: () => `${JSON.stringify(pin, null, 2)}\n`,
+		catch: (cause) => new LocalResolutionPinSerializationError(cause)
+	});
+}
+function writeLocalResolutionPinBoundary(run, operation, signal) {
+	return Result.tryPromise({
+		try: async () => {
+			await run();
+		},
+		catch: (cause) => signal?.aborted ? new LocalResolutionPinWriteAbortedError(cause) : new LocalResolutionPinWriteFailedError(operation, cause)
+	});
+}
+function ensureLocalResolutionPinGitignoreUpdateNotAborted(signal) {
+	return Result.try({
+		try: () => signal?.throwIfAborted(),
+		catch: (cause) => new LocalResolutionPinGitignoreUpdateAbortedError(cause)
+	});
+}
+function writeLocalResolutionPinGitignore(gitignorePath, contents, signal) {
+	return Result.tryPromise({
+		try: () => writeFile(gitignorePath, contents, {
 			encoding: "utf8",
 			signal
-		});
-		return;
-	}
-	if (existing.split(/\r?\n/).map((line) => line.trim()).some((line) => line === ".prisma/" || line === ".prisma/local.json")) return;
-	await writeFile(gitignorePath, existing.endsWith("\n") ? `${existing}.prisma/\n` : `${existing}\n.prisma/\n`, {
-		encoding: "utf8",
-		signal
+		}),
+		catch: (cause) => signal?.aborted ? new LocalResolutionPinGitignoreUpdateAbortedError(cause) : new LocalResolutionPinGitignoreUpdateFailedError("write", cause)
 	});
 }
 function isLocalResolutionPin(value) {

package/dist/lib/project/resolution.js

@@ -3,45 +3,98 @@ import { formatCommandArgument } from "../../shell/command-arguments.js";
 import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin } from "./local-pin.js";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { matchError } from "better-result";
+import { Result, TaggedError, matchError } from "better-result";
 //#region src/lib/project/resolution.ts
+var ProjectNotFoundError = class extends TaggedError("ProjectNotFoundError")() {
+	constructor(projectRef, workspace) {
+		super({
+			message: `Project "${projectRef}" was not found in workspace "${workspace.name}".`,
+			projectRef,
+			workspace
+		});
+	}
+};
+var ProjectAmbiguousError = class extends TaggedError("ProjectAmbiguousError")() {
+	constructor(projectRef, matches) {
+		super({
+			message: projectRef ? `Multiple projects matched "${projectRef}".` : "Multiple projects matched the current directory context.",
+			projectRef,
+			matches
+		});
+	}
+};
+var LocalStateStaleError = class extends TaggedError("LocalStateStaleError")() {
+	constructor() {
+		super({
+			message: `The target recorded in ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} is no longer available in the selected workspace.`,
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
+		});
+	}
+};
+var LocalProjectWorkspaceMismatchError = class extends TaggedError("LocalProjectWorkspaceMismatchError")() {
+	constructor(options) {
+		super({
+			message: `${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} links this directory to project ${options.pinnedProjectId} in workspace ${options.pinnedWorkspaceId}, but the active workspace is "${options.activeWorkspace.name}" (${options.activeWorkspace.id}).`,
+			pinnedWorkspaceId: options.pinnedWorkspaceId,
+			pinnedProjectId: options.pinnedProjectId,
+			activeWorkspace: options.activeWorkspace
+		});
+	}
+};
+var ProjectSetupRequiredError = class extends TaggedError("ProjectSetupRequiredError")() {
+	constructor(options) {
+		const commandLabel = options.commandName ? `prisma-cli ${options.commandName}` : "this command";
+		super({
+			message: `This directory is not linked to a Prisma Project, and ${commandLabel} will not choose one from package or directory names.`,
+			commandName: options.commandName,
+			suggestion: options.suggestion
+		});
+	}
+};
 async function resolveProjectTarget(options) {
-	const localPin = await readImplicitLocalPin(options, { allowEnvProjectId: true });
-	const projects = await options.listProjects();
-	const target = await resolveBoundProjectTarget(options, projects, {
-		allowEnvProjectId: true,
-		localPin
-	});
-	if (target) return target;
-	throw await projectSetupRequiredError({
-		cwd: options.context.runtime.cwd,
-		projects,
-		commandName: options.commandName,
-		signal: options.context.runtime.signal
+	return Result.gen(async function* () {
+		const localPin = yield* Result.await(readImplicitLocalPin(options, { allowEnvProjectId: true }));
+		const projects = await options.listProjects();
+		const target = yield* Result.await(resolveBoundProjectTarget(options, projects, {
+			allowEnvProjectId: true,
+			localPin
+		}));
+		if (target) return Result.ok(target);
+		return Result.err(await projectSetupRequiredError({
+			cwd: options.context.runtime.cwd,
+			projects,
+			commandName: options.commandName,
+			signal: options.context.runtime.signal
+		}));
 	});
 }
 async function inspectProjectBinding(options) {
-	const localPin = await readImplicitLocalPin(options, { allowEnvProjectId: false });
-	const projects = await options.listProjects();
-	const target = await resolveBoundProjectTarget(options, projects, {
-		allowEnvProjectId: false,
-		localPin
+	return Result.gen(async function* () {
+		const localPin = yield* Result.await(readImplicitLocalPin(options, { allowEnvProjectId: false }));
+		const projects = await options.listProjects();
+		const target = yield* Result.await(resolveBoundProjectTarget(options, projects, {
+			allowEnvProjectId: false,
+			localPin
+		}));
+		if (target) return Result.ok(target);
+		return Result.ok({
+			workspace: options.workspace,
+			project: null,
+			localBinding: { status: "not-linked" },
+			resolution: { projectSource: "unbound" },
+			...await buildProjectSetupSuggestion({
+				cwd: options.context.runtime.cwd,
+				projects,
+				commandName: options.commandName ?? "project show",
+				signal: options.context.runtime.signal
+			})
+		});
 	});
-	if (target) return target;
-	return {
-		workspace: options.workspace,
-		project: null,
-		localBinding: { status: "not-linked" },
-		resolution: { projectSource: "unbound" },
-		...await buildProjectSetupSuggestion({
-			cwd: options.context.runtime.cwd,
-			projects,
-			commandName: options.commandName ?? "project show",
-			signal: options.context.runtime.signal
-		})
-	};
 }
 function projectNotFoundError(projectRef, workspace) {
+	return projectResolutionErrorToCliError(new ProjectNotFoundError(projectRef, workspace));
+}
+function projectNotFoundCliError(projectRef, workspace) {
 	return new CliError({
 		code: "PROJECT_NOT_FOUND",
 		domain: "project",
@@ -53,6 +106,9 @@ function projectNotFoundError(projectRef, workspace) {
 	});
 }
 function projectAmbiguousError(projectRef, matches) {
+	return projectResolutionErrorToCliError(new ProjectAmbiguousError(projectRef, matches));
+}
+function projectAmbiguousCliError(projectRef, matches) {
 	const firstMatch = matches[0];
 	const nextSteps = ["prisma-cli project list"];
 	if (firstMatch) nextSteps.push(`prisma-cli app deploy --project ${firstMatch.id}`);
@@ -70,7 +126,7 @@ function projectAmbiguousError(projectRef, matches) {
 		nextSteps
 	});
 }
-function localStateStaleError() {
+function localStateStaleCliError() {
 	return new CliError({
 		code: "LOCAL_STATE_STALE",
 		domain: "project",
@@ -82,7 +138,7 @@ function localStateStaleError() {
 		nextSteps: ["prisma-cli project list", "prisma-cli project link <id-or-name>"]
 	});
 }
-function localProjectWorkspaceMismatchError(options) {
+function localProjectWorkspaceMismatchCliError(options) {
 	return new CliError({
 		code: "LOCAL_PROJECT_WORKSPACE_MISMATCH",
 		domain: "project",
@@ -104,6 +160,31 @@ function localProjectWorkspaceMismatchError(options) {
 		]
 	});
 }
+/**
+* Converts expected project-resolution variants to command-boundary CliErrors.
+* `LocalResolutionPinReadAbortedError` and `UnhandledException` intentionally
+* propagate as exceptions; callers such as `resolveProjectShowInRealMode`
+* throw this helper's result, so passthrough variants should keep bubbling.
+*/
+function projectResolutionErrorToCliError(error) {
+	return matchError(error, {
+		ProjectNotFoundError: (error) => projectNotFoundCliError(error.projectRef, error.workspace),
+		ProjectAmbiguousError: (error) => projectAmbiguousCliError(error.projectRef, error.matches),
+		ProjectSetupRequiredError: (error) => projectSetupRequiredCliError(error),
+		LocalStateStaleError: () => localStateStaleCliError(),
+		LocalProjectWorkspaceMismatchError: (error) => localProjectWorkspaceMismatchCliError({
+			pinnedWorkspaceId: error.pinnedWorkspaceId,
+			pinnedProjectId: error.pinnedProjectId,
+			activeWorkspace: error.activeWorkspace
+		}),
+		LocalResolutionPinReadAbortedError: (error) => {
+			throw error;
+		},
+		UnhandledException: (error) => {
+			throw error;
+		}
+	});
+}
 async function buildProjectSetupSuggestion(options) {
 	const suggestedName = await inferTargetName(options.cwd, options.signal);
 	const candidates = sortProjects(options.projects.filter((project) => projectMatchesSuggestedName(project, suggestedName.name))).map(toProjectSummary);
@@ -116,17 +197,24 @@ async function buildProjectSetupSuggestion(options) {
 }
 async function projectSetupRequiredError(options) {
 	const suggestion = await buildProjectSetupSuggestion(options);
+	return new ProjectSetupRequiredError({
+		commandName: options.commandName,
+		suggestion
+	});
+}
+function projectSetupRequiredCliError(error) {
+	const suggestion = error.suggestion;
 	return new CliError({
 		code: "PROJECT_SETUP_REQUIRED",
 		domain: "project",
 		summary: "Choose a Project before running this command",
-		why: `This directory is not linked to a Prisma Project, and ${options.commandName ? `prisma-cli ${options.commandName}` : "this command"} will not choose one from package or directory names.`,
+		why: error.message,
 		fix: "Link the directory to an existing Project, or pass --project <id-or-name> for this command.",
 		meta: { ...suggestion },
 		exitCode: 1,
 		nextSteps: ["prisma-cli project list", ...suggestion.recoveryCommands],
 		nextActions: buildProjectSetupNextActions({
-			commandName: options.commandName,
+			commandName: error.commandName,
 			suggestedProjectName: suggestion.suggestedProjectName
 		})
 	});
@@ -200,9 +288,9 @@ function sortProjects(projects) {
 }
 function resolveExplicitProject(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);
-	throw projectNotFoundError(projectRef, workspace);
+	if (matches.length === 1) return Result.ok(matches[0]);
+	if (matches.length > 1) return Result.err(new ProjectAmbiguousError(projectRef, matches));
+	return Result.err(new ProjectNotFoundError(projectRef, workspace));
 }
 function projectMatchesSuggestedName(project, suggestedName) {
 	return project.id === suggestedName || project.name === suggestedName || project.slug === suggestedName;
@@ -211,62 +299,62 @@ async function resolveDurablePlatformMapping() {
 	return null;
 }
 async function resolveBoundProjectTarget(options, projects, settings) {
-	if (options.explicitProject) return resolvedTarget(options.workspace, resolveExplicitProject(options.explicitProject, projects, options.workspace), "explicit", {
-		targetName: options.explicitProject,
-		targetNameSource: "explicit"
-	});
+	if (options.explicitProject) {
+		const projectResult = resolveExplicitProject(options.explicitProject, projects, options.workspace);
+		if (projectResult.isErr()) return Result.err(projectResult.error);
+		return Result.ok(resolvedTarget(options.workspace, projectResult.value, "explicit", {
+			targetName: options.explicitProject,
+			targetNameSource: "explicit"
+		}));
+	}
 	if (settings.allowEnvProjectId && options.envProjectId) {
 		const project = projects.find((candidate) => candidate.id === options.envProjectId);
-		if (!project) throw projectNotFoundError(options.envProjectId, options.workspace);
-		return resolvedTarget(options.workspace, project, "env", {
+		if (!project) return Result.err(new ProjectNotFoundError(options.envProjectId, options.workspace));
+		return Result.ok(resolvedTarget(options.workspace, project, "env", {
 			targetName: options.envProjectId,
 			targetNameSource: "env"
-		});
+		}));
 	}
 	const localPin = settings.localPin;
-	if (!localPin) return null;
+	if (!localPin) return Result.ok(null);
 	if (localPin.kind === "present") {
-		if (localPin.pin.workspaceId !== options.workspace.id) throw localProjectWorkspaceMismatchError({
+		if (localPin.pin.workspaceId !== options.workspace.id) return Result.err(new LocalProjectWorkspaceMismatchError({
 			pinnedWorkspaceId: localPin.pin.workspaceId,
 			pinnedProjectId: localPin.pin.projectId,
 			activeWorkspace: options.workspace
-		});
+		}));
 		const project = projects.find((candidate) => candidate.id === localPin.pin.projectId);
-		if (!project) throw localStateStaleError();
-		return resolvedTarget(options.workspace, project, "local-pin", {
+		if (!project) return Result.err(new LocalStateStaleError());
+		return Result.ok(resolvedTarget(options.workspace, project, "local-pin", {
 			targetName: project.name,
 			targetNameSource: "local-pin"
-		});
+		}));
 	}
 	const platformMapping = await resolveDurablePlatformMapping();
-	if (platformMapping && platformMapping.workspace.id === options.workspace.id) return resolvedTarget(options.workspace, platformMapping, "platform-mapping", {
+	if (platformMapping && platformMapping.workspace.id === options.workspace.id) return Result.ok(resolvedTarget(options.workspace, platformMapping, "platform-mapping", {
 		targetName: platformMapping.name,
 		targetNameSource: "platform-mapping"
-	});
-	return null;
+	}));
+	return Result.ok(null);
 }
 async function readImplicitLocalPin(options, settings) {
-	if (options.explicitProject || settings.allowEnvProjectId && options.envProjectId) return null;
+	if (options.explicitProject || settings.allowEnvProjectId && options.envProjectId) return Result.ok(null);
 	const localPinResult = await readLocalResolutionPin(options.context.runtime.cwd, options.context.runtime.signal);
-	if (localPinResult.isErr()) throw localPinReadErrorToProjectError(localPinResult.error);
+	if (localPinResult.isErr()) return Result.err(localPinReadErrorToProjectError(localPinResult.error));
 	const localPin = localPinResult.value;
-	if (localPin.kind === "present" && localPin.pin.workspaceId !== options.workspace.id) throw localProjectWorkspaceMismatchError({
+	if (localPin.kind === "present" && localPin.pin.workspaceId !== options.workspace.id) return Result.err(new LocalProjectWorkspaceMismatchError({
 		pinnedWorkspaceId: localPin.pin.workspaceId,
 		pinnedProjectId: localPin.pin.projectId,
 		activeWorkspace: options.workspace
-	});
-	return localPin;
+	}));
+	return Result.ok(localPin);
 }
 function localPinReadErrorToProjectError(error) {
 	return matchError(error, {
-		LocalResolutionPinInvalidJsonError: () => localStateStaleError(),
-		LocalResolutionPinInvalidShapeError: () => localStateStaleError(),
-		LocalResolutionPinReadAbortedError: (error) => {
-			throw error;
-		},
-		UnhandledException: (error) => {
-			throw error;
-		}
+		LocalResolutionPinInvalidJsonError: () => new LocalStateStaleError(),
+		LocalResolutionPinInvalidShapeError: () => new LocalStateStaleError(),
+		LocalResolutionPinReadAbortedError: (error) => error,
+		UnhandledException: (error) => error
 	});
 }
 function resolvedTarget(workspace, project, projectSource, resolutionDetails) {
@@ -292,4 +380,4 @@ function toProjectSummary(project) {
 	};
 }
 //#endregion
-export { buildProjectSetupNextActions, inferTargetName, inspectProjectBinding, projectAmbiguousError, projectNotFoundError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects };
+export { buildProjectSetupNextActions, inferTargetName, inspectProjectBinding, projectAmbiguousError, projectNotFoundError, projectResolutionErrorToCliError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects };

package/dist/lib/project/setup.js

@@ -2,6 +2,7 @@ import { CliError, usageError } from "../../shell/errors.js";
 import "../../shell/command-arguments.js";
 import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, ensureLocalResolutionPinGitignore, writeLocalResolutionPin } from "./local-pin.js";
 import { projectAmbiguousError, projectNotFoundError } from "./resolution.js";
+import { Result, matchError } from "better-result";
 //#region src/lib/project/setup.ts
 function isValidProjectSetupName(projectName) {
 	return projectName.trim().length > 0;
@@ -17,21 +18,63 @@ function resolveProjectForSetup(projectRef, projects, workspace) {
 	throw projectNotFoundError(projectRef, workspace);
 }
 async function bindProjectToDirectory(context, workspace, project, action) {
-	await writeLocalResolutionPin(context.runtime.cwd, {
-		workspaceId: workspace.id,
-		projectId: project.id
-	}, context.runtime.signal);
-	await ensureLocalResolutionPinGitignore(context.runtime.cwd, context.runtime.signal);
-	return {
-		workspace,
-		project,
-		directory: formatSetupDirectory(context.runtime.cwd),
-		localPin: {
-			path: LOCAL_RESOLUTION_PIN_RELATIVE_PATH,
-			written: true
+	return Result.gen(async function* () {
+		yield* Result.await(writeLocalResolutionPin(context.runtime.cwd, {
+			workspaceId: workspace.id,
+			projectId: project.id
+		}, context.runtime.signal));
+		yield* Result.await(ensureLocalResolutionPinGitignore(context.runtime.cwd, context.runtime.signal));
+		return Result.ok({
+			workspace,
+			project,
+			directory: formatSetupDirectory(context.runtime.cwd),
+			localPin: {
+				path: LOCAL_RESOLUTION_PIN_RELATIVE_PATH,
+				written: true
+			},
+			action
+		});
+	});
+}
+function projectDirectoryBindingErrorToCliError(error) {
+	return matchError(error, {
+		LocalResolutionPinSerializationError: (error) => {
+			throw error;
 		},
-		action
-	};
+		LocalResolutionPinWriteAbortedError: (error) => {
+			throw error;
+		},
+		LocalResolutionPinWriteFailedError: (error) => localStateWriteFailedError(error, {
+			why: `The CLI could not write ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH}.`,
+			meta: {
+				pinPath: error.pinPath,
+				operation: error.operation
+			}
+		}),
+		LocalResolutionPinGitignoreUpdateAbortedError: (error) => {
+			throw error;
+		},
+		LocalResolutionPinGitignoreUpdateFailedError: (error) => localStateWriteFailedError(error, {
+			why: "The CLI could not update .gitignore to keep local Project binding state out of git.",
+			meta: {
+				gitignorePath: error.gitignorePath,
+				operation: error.operation
+			}
+		})
+	});
+}
+function localStateWriteFailedError(error, options) {
+	return new CliError({
+		code: "LOCAL_STATE_WRITE_FAILED",
+		domain: "project",
+		summary: "Could not save local Project binding",
+		why: options.why,
+		fix: "Check that this directory is writable and that .prisma/local.json and .gitignore are not blocked by directories or permissions, then retry.",
+		debug: formatDebugDetails(error.cause),
+		meta: options.meta,
+		exitCode: 1,
+		nextSteps: ["prisma-cli project link <id-or-name>", "prisma-cli app deploy --project <id-or-name>"]
+	});
 }
 function toProjectSummary(project) {
 	return {
@@ -86,4 +129,4 @@ function formatDebugDetails(error) {
 	return typeof error === "string" ? error : null;
 }
 //#endregion
-export { bindProjectToDirectory, isValidProjectSetupName, projectCreateFailedError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary, validateProjectSetupNameText };
+export { bindProjectToDirectory, isValidProjectSetupName, projectCreateFailedError, projectDirectoryBindingErrorToCliError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary, validateProjectSetupNameText };

package/package.json

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