@prisma/cli 3.0.0-dev.38.1 → 3.0.0-dev.39.1

package/dist/commands/app/index.js

@@ -59,7 +59,7 @@ function createRunCommand(runtime) {
 }
 function createDeployCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("deploy"), runtime), "app.deploy");
-	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--branch <name>", "Branch name")).addOption(new Option("--framework <name>", "Framework to deploy").choices([
+	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--create-project <name>", "Create and link a new Project before deploying")).addOption(new Option("--branch <name>", "Branch name")).addOption(new Option("--framework <name>", "Framework to deploy").choices([
 		"nextjs",
 		"hono",
 		"tanstack-start"
@@ -74,8 +74,10 @@ function createDeployCommand(runtime) {
 		const httpPort = options.httpPort;
 		const envAssignments = options.env;
 		const projectRef = options.project;
+		const createProjectName = options.createProject;
 		await runCommand(runtime, "app.deploy", options, (context) => runAppDeploy(context, appName, {
 			projectRef,
+			createProjectName,
 			branchName,
 			entrypoint: entry,
 			buildType,

package/dist/commands/project/index.js

@@ -1,9 +1,9 @@
 import { attachCommandDescriptor } from "../../shell/command-meta.js";
 import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
-import { runProjectList, runProjectShow } from "../../controllers/project.js";
+import { runProjectCreate, runProjectLink, runProjectList, runProjectShow } from "../../controllers/project.js";
 import { runCommand } from "../../shell/command-runner.js";
-import { renderProjectList, renderProjectShow, serializeProjectList, serializeProjectShow } from "../../presenters/project.js";
+import { renderProjectList, renderProjectSetup, renderProjectShow, serializeProjectList, serializeProjectSetup, serializeProjectShow } from "../../presenters/project.js";
 import { createEnvCommand } from "../env.js";
 import { Command } from "commander";
 //#region src/commands/project/index.ts
@@ -12,9 +12,35 @@ function createProjectCommand(runtime) {
 	addCompactGlobalFlags(project);
 	project.addCommand(createProjectListCommand(runtime));
 	project.addCommand(createProjectShowCommand(runtime));
+	project.addCommand(createProjectCreateCommand(runtime));
+	project.addCommand(createProjectLinkCommand(runtime));
 	project.addCommand(createEnvCommand(runtime));
 	return project;
 }
+function createProjectCreateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "project.create");
+	command.argument("<name>", "Project name");
+	addGlobalFlags(command);
+	command.action(async (name, options) => {
+		await runCommand(runtime, "project.create", options, (context) => runProjectCreate(context, String(name)), {
+			renderHuman: (context, descriptor, result) => renderProjectSetup(context, descriptor, result),
+			renderJson: (result) => serializeProjectSetup(result)
+		});
+	});
+	return command;
+}
+function createProjectLinkCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("link"), runtime), "project.link");
+	command.argument("<id-or-name>", "Project id or name");
+	addGlobalFlags(command);
+	command.action(async (projectRef, options) => {
+		await runCommand(runtime, "project.link", options, (context) => runProjectLink(context, String(projectRef)), {
+			renderHuman: (context, descriptor, result) => renderProjectSetup(context, descriptor, result),
+			renderJson: (result) => serializeProjectSetup(result)
+		});
+	});
+	return command;
+}
 function createProjectListCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "project.list");
 	addGlobalFlags(command);

package/dist/controllers/app.js

@@ -11,8 +11,9 @@ import { parseEnvAssignments } from "../lib/app/env-vars.js";
 import { renderDeployOutputRows } from "../lib/app/deploy-output.js";
 import { readBunPackageJson } from "../lib/app/bun-project.js";
 import { DEFAULT_LOCAL_DEV_PORT, resolveLocalBuildType, runLocalApp } from "../lib/app/local-dev.js";
-import { inferTargetName, projectNotFoundError, resolveProjectTarget } from "../lib/project/resolution.js";
-import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, ensureLocalResolutionPinGitignore, readLocalResolutionPin, writeLocalResolutionPin } from "../lib/project/local-pin.js";
+import { inferTargetName, projectNotFoundError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
+import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin } from "../lib/project/local-pin.js";
+import { bindProjectToDirectory, formatCommandArgument, projectCreateFailedError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
 import { PREVIEW_BUILD_TYPES, RESOLVED_PREVIEW_BUILD_TYPES, executePreviewBuild } from "../lib/app/preview-build.js";
 import { PREVIEW_DEFAULT_REGION } from "../lib/app/preview-interaction.js";
 import { createPreviewDeployProgress, createPreviewDeployProgressState, createPreviewPromoteProgress } from "../lib/app/preview-progress.js";
@@ -96,44 +97,54 @@ async function runAppDeploy(context, appName, options) {
 	ensurePreviewAppMode(context);
 	const envProjectId = readDeployEnvOverride(context, PRISMA_PROJECT_ID_ENV_VAR);
 	const envAppId = readDeployEnvOverride(context, PRISMA_APP_ID_ENV_VAR);
-	const skipLocalPin = Boolean(envProjectId || envAppId);
+	assertExclusiveDeployProjectInputs({
+		projectRef: options?.projectRef,
+		createProjectName: options?.createProjectName,
+		envProjectId
+	});
+	const skipLocalPin = Boolean(envProjectId || options?.projectRef || options?.createProjectName);
 	const localPin = skipLocalPin ? { kind: "missing" } : await readLocalResolutionPin(context.runtime.cwd);
 	if (!skipLocalPin && localPin.kind === "invalid") throw localResolutionPinStaleError();
 	const explicitBuildType = Boolean(options?.buildType && options.buildType !== "auto");
-	const branch = await resolveDeployBranch(context, options?.branchName);
 	if (options?.httpPort) parseDeployHttpPort(options.httpPort);
-	let framework = await resolveDeployFramework(context, {
+	assertSupportedEntrypointForRequestedDeployShape({
 		requestedFramework: options?.framework,
 		requestedBuildType: options?.buildType,
-		explicitBuildType
+		explicitBuildType,
+		entrypoint: options?.entrypoint
 	});
-	let runtime = resolveDeployRuntime(options?.httpPort, framework);
-	assertSupportedEntrypoint(framework.buildType, options?.entrypoint, "deploy");
-	const envVars = toOptionalEnvVars(parseEnvAssignments(options?.envAssignments, { commandName: "deploy" }));
-	const firstDeploy = !skipLocalPin && localPin.kind === "missing";
+	const branch = await resolveDeployBranch(context, options?.branchName);
 	const { provider, target, projectId } = await requireProviderAndDeployProjectContext(context, options?.projectRef, {
-		allowCreate: true,
 		branch,
+		createProjectName: options?.createProjectName,
 		envProjectId,
 		localPin
 	});
+	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);
+	}
+	let framework = await resolveDeployFramework(context, {
+		requestedFramework: options?.framework,
+		requestedBuildType: options?.buildType,
+		explicitBuildType
+	});
+	let runtime = resolveDeployRuntime(options?.httpPort, framework);
+	assertSupportedEntrypoint(framework.buildType, options?.entrypoint, "deploy");
+	const envVars = toOptionalEnvVars(parseEnvAssignments(options?.envAssignments, { commandName: "deploy" }));
 	const selectedApp = await resolveDeployAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), {
 		explicitAppName: appName,
 		explicitAppId: envAppId,
-		firstDeploy,
+		firstDeploy: Boolean(target.localPinAction),
 		inferName: () => inferTargetName(context.runtime.cwd)
 	});
 	await maybeRenderDeploySetupBlock(context, {
-		firstDeploy: selectedApp.firstDeploy,
-		workspaceName: target.workspace.name,
+		includeDirectory: !target.localPinAction,
 		projectName: target.project.name,
-		projectAnnotation: annotationForProjectResolution(target.resolution),
 		branchName: target.branch.name,
-		branchAnnotation: branch.annotation,
-		appName: selectedApp.displayName,
-		appAnnotation: selectedApp.annotation,
-		framework,
-		runtime
+		appName: selectedApp.displayName
 	});
 	const customized = await maybeCustomizeDeploySettings(context, {
 		framework,
@@ -148,15 +159,6 @@ async function runAppDeploy(context, appName, options) {
 	const buildType = framework.buildType;
 	assertSupportedEntrypoint(buildType, options?.entrypoint, "deploy");
 	const portMapping = parseDeployPortMapping(String(runtime.port));
-	const shouldWriteLocalPin = firstDeploy && !skipLocalPin;
-	if (shouldWriteLocalPin) {
-		await writeLocalResolutionPin(context.runtime.cwd, {
-			workspaceId: target.workspace.id,
-			projectId: target.project.id
-		});
-		await ensureLocalResolutionPinGitignore(context.runtime.cwd);
-		maybeRenderLocalPinBound(context, target.project.name);
-	}
 	const progressState = createPreviewDeployProgressState();
 	const deployStartedAt = Date.now();
 	const deployResult = await provider.deployApp({
@@ -194,10 +196,7 @@ async function runAppDeploy(context, appName, options) {
 			},
 			deployment: deployResult.deployment,
 			durationMs: deployDurationMs,
-			localPin: shouldWriteLocalPin ? {
-				path: LOCAL_RESOLUTION_PIN_RELATIVE_PATH,
-				written: true
-			} : void 0
+			localPin: localPinResult
 		},
 		warnings: [],
 		nextSteps: ["prisma-cli app list-deploys", `prisma-cli app show-deploy ${deployResult.deployment.id}`]
@@ -719,11 +718,10 @@ async function resolveAppDomainTarget(context, options) {
 	});
 	const envProjectId = readDeployEnvOverride(context, PRISMA_PROJECT_ID_ENV_VAR);
 	const envAppId = readDeployEnvOverride(context, PRISMA_APP_ID_ENV_VAR);
-	const skipLocalPin = Boolean(envProjectId || envAppId);
+	const skipLocalPin = Boolean(envProjectId);
 	const localPin = skipLocalPin ? { kind: "missing" } : await readLocalResolutionPin(context.runtime.cwd);
 	if (!skipLocalPin && localPin.kind === "invalid") throw localResolutionPinStaleError();
 	const { provider, target, projectId } = await requireProviderAndDeployProjectContext(context, options?.projectRef, {
-		allowCreate: false,
 		branch,
 		envProjectId,
 		localPin
@@ -1258,7 +1256,7 @@ function createPreviewLogAuthOptions(env) {
 }
 async function requireProviderAndProjectContext(context, explicitProject, options) {
 	const { client, provider } = await requirePreviewAppProviderWithClient(context);
-	const target = await resolveProjectContext(context, client, provider, explicitProject, options);
+	const target = await resolveProjectContext(context, client, explicitProject, options);
 	return {
 		client,
 		provider,
@@ -1276,7 +1274,7 @@ async function requireProviderAndDeployProjectContext(context, explicitProject,
 		projectId: target.project.id
 	};
 }
-async function resolveProjectContext(context, client, provider, explicitProject, options) {
+async function resolveProjectContext(context, client, explicitProject, options) {
 	const authState = await requireAuthenticatedAuthState(context);
 	if (!authState.workspace) throw workspaceRequiredError();
 	const resolved = await resolveProjectTarget({
@@ -1284,22 +1282,6 @@ async function resolveProjectContext(context, client, provider, explicitProject,
 		workspace: authState.workspace,
 		explicitProject,
 		listProjects: () => listRealWorkspaceProjects(client, authState.workspace),
-		createProject: options?.allowCreate ? async (name) => {
-			const project = await provider.createProject({ name }).catch((error) => {
-				throw createProjectOnFirstDeployError({
-					error,
-					inferredName: name,
-					workspaceName: authState.workspace.name
-				});
-			});
-			return {
-				id: project.id,
-				name: project.name,
-				workspace: authState.workspace
-			};
-		} : void 0,
-		allowCreate: options?.allowCreate,
-		prompt: createSelectPromptPort(context),
 		remember: true
 	});
 	const branch = options?.branch ?? await resolveDeployBranch(context, void 0);
@@ -1316,30 +1298,30 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 	if (!workspace) throw workspaceRequiredError();
 	const branch = options.branch ?? await resolveDeployBranch(context, void 0);
 	const projects = await listRealWorkspaceProjects(client, workspace);
-	const createProject = options.allowCreate ? async (name) => {
-		const project = await provider.createProject({ name }).catch((error) => {
-			throw createProjectOnFirstDeployError({
-				error,
-				inferredName: name,
-				workspaceName: workspace.name
-			});
-		});
-		return {
-			id: project.id,
-			name: project.name,
-			workspace
-		};
-	} : void 0;
-	if (explicitProject) return withDeployBranch(await resolveProjectTarget({
-		context,
+	if (explicitProject) return withDeployBranch({
 		workspace,
-		explicitProject,
-		listProjects: async () => projects,
-		createProject,
-		allowCreate: options.allowCreate,
-		prompt: createSelectPromptPort(context),
-		remember: true
-	}), branch);
+		project: toProjectSummary(resolveProjectForSetup(explicitProject, projects, workspace)),
+		resolution: {
+			projectSource: "explicit",
+			targetName: explicitProject,
+			targetNameSource: "explicit"
+		},
+		localPinAction: "linked"
+	}, branch);
+	if (options.createProjectName) {
+		const projectName = options.createProjectName.trim();
+		if (!projectName) throw projectSetupNameRequiredError("app deploy --create-project");
+		return withDeployBranch({
+			workspace,
+			project: toProjectSummary(await createProjectForDeploySetup(provider, projectName, workspace)),
+			resolution: {
+				projectSource: "created",
+				targetName: projectName,
+				targetNameSource: "explicit"
+			},
+			localPinAction: "created"
+		}, branch);
+	}
 	if (options.envProjectId) {
 		const project = projects.find((candidate) => candidate.id === options.envProjectId);
 		if (!project) throw projectNotFoundError(options.envProjectId, workspace);
@@ -1368,15 +1350,91 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 			}
 		}, branch);
 	}
-	return withDeployBranch(await resolveProjectTarget({
-		context,
+	const platformMapping = await resolveDurablePlatformMapping();
+	if (platformMapping && platformMapping.workspace.id === workspace.id) return withDeployBranch({
 		workspace,
-		listProjects: async () => projects,
-		createProject,
-		allowCreate: options.allowCreate,
-		prompt: createSelectPromptPort(context),
-		remember: true
-	}), branch);
+		project: toProjectSummary(platformMapping),
+		resolution: {
+			projectSource: "platform-mapping",
+			targetName: platformMapping.name,
+			targetNameSource: "platform-mapping"
+		}
+	}, branch);
+	if (canPrompt(context) && !context.flags.yes) return withDeployBranch(await resolveInteractiveDeployProjectSetup(context, provider, workspace, projects), branch);
+	throw projectSetupRequiredError(projects, await inferTargetName(context.runtime.cwd));
+}
+async function resolveInteractiveDeployProjectSetup(context, provider, workspace, projects) {
+	const sortedProjects = sortProjects(projects);
+	const choice = await selectPrompt({
+		input: context.runtime.stdin,
+		output: context.runtime.stderr,
+		message: "Which Project should this directory use?",
+		choices: [
+			...sortedProjects.map((project) => ({
+				label: project.name,
+				value: {
+					kind: "project",
+					project
+				}
+			})),
+			{
+				label: "Create a new Project",
+				value: { kind: "create" }
+			},
+			{
+				label: "Cancel",
+				value: { kind: "cancel" }
+			}
+		]
+	});
+	if (choice.kind === "cancel") throw usageError("Project setup canceled", "Deploy needs a Project before it can continue.", "Choose an existing Project or create a new one, then rerun deploy.", ["prisma-cli app deploy --project <id-or-name>", "prisma-cli app deploy --create-project <name>"], "project");
+	if (choice.kind === "project") return {
+		workspace,
+		project: toProjectSummary(choice.project),
+		resolution: {
+			projectSource: "prompt",
+			targetName: choice.project.name,
+			targetNameSource: "prompt"
+		},
+		localPinAction: "linked"
+	};
+	const suggestedName = await inferTargetName(context.runtime.cwd);
+	const rawName = await textPrompt({
+		input: context.runtime.stdin,
+		output: context.runtime.stderr,
+		message: "Project name",
+		placeholder: suggestedName.name,
+		validate: (value) => validateProjectSetupNameText(value, suggestedName.name)
+	});
+	const projectName = rawName.trim() || suggestedName.name;
+	return {
+		workspace,
+		project: toProjectSummary(await createProjectForDeploySetup(provider, projectName, workspace)),
+		resolution: {
+			projectSource: "created",
+			targetName: projectName,
+			targetNameSource: rawName.trim() ? "prompt" : suggestedName.source
+		},
+		localPinAction: "created"
+	};
+}
+async function createProjectForDeploySetup(provider, projectName, workspace) {
+	const created = await provider.createProject({ name: projectName }).catch((error) => {
+		throw projectCreateFailedError(error, projectName, workspace, {
+			nextSteps: [
+				"prisma-cli project list",
+				"prisma-cli app deploy --project <id-or-name>",
+				`prisma-cli app deploy --create-project ${formatCommandArgument(projectName)}`
+			],
+			permissionFix: "Choose an existing Project with --project, or grant the token permission to create Projects in this workspace.",
+			fallbackFix: "Choose an existing Project with --project, or retry after addressing the platform error above."
+		});
+	});
+	return {
+		id: created.id,
+		name: created.name,
+		workspace
+	};
 }
 function withDeployBranch(target, branch) {
 	return {
@@ -1387,15 +1445,26 @@ function withDeployBranch(target, branch) {
 		}
 	};
 }
-function toProjectSummary(project) {
-	return {
-		id: project.id,
-		name: project.name
-	};
-}
 function toBranchKind(name) {
 	return name === "production" || name === "main" ? "production" : "preview";
 }
+function assertExclusiveDeployProjectInputs(options) {
+	const provided = [
+		options.projectRef ? "--project" : null,
+		options.createProjectName ? "--create-project" : null,
+		options.envProjectId ? PRISMA_PROJECT_ID_ENV_VAR : null
+	].filter((value) => Boolean(value));
+	if (provided.length <= 1) return;
+	throw usageError("Project selection is ambiguous", `${provided.join(", ")} cannot be used together.`, "Choose exactly one Project source for this deploy.", [
+		"prisma-cli app deploy --project <id-or-name>",
+		"prisma-cli app deploy --create-project <name>",
+		`unset ${PRISMA_PROJECT_ID_ENV_VAR}`
+	], "project");
+}
+function validateProjectSetupNameText(value, fallback) {
+	if ((value?.trim() || fallback).trim().length > 0) return;
+	return "Enter a Project name.";
+}
 async function resolveDeployBranch(context, explicitBranchName) {
 	if (explicitBranchName) return {
 		name: explicitBranchName,
@@ -1459,6 +1528,14 @@ function resolveDeployRuntime(requestedHttpPort, framework) {
 		annotation: `${framework.displayName} default`
 	};
 }
+function assertSupportedEntrypointForRequestedDeployShape(options) {
+	if (options.requestedFramework) {
+		assertSupportedEntrypoint(frameworkFromUserFacingValue(options.requestedFramework, "set by --framework").buildType, options.entrypoint, "deploy");
+		return;
+	}
+	if (!options.explicitBuildType) return;
+	assertSupportedEntrypoint(normalizeBuildType(options.requestedBuildType), options.entrypoint, "deploy");
+}
 async function detectDeployFramework(cwd) {
 	const packageJson = await readBunPackageJson(cwd);
 	const nextConfig = await detectNextConfig(cwd);
@@ -1558,53 +1635,12 @@ function frameworkNotDetectedError(cwd, requestedFramework) {
 async function maybeRenderDeploySetupBlock(context, details) {
 	if (context.flags.json || context.flags.quiet) return;
 	const directory = formatDeployDirectory(context.runtime.cwd);
-	if (!details.firstDeploy) {
-		context.output.stderr.write(`Deploying ${directory} to ${details.projectName} / ${details.branchName} / ${details.appName}\n\n`);
-		return;
-	}
-	const title = `Setting up your local directory ${formatLocalDirectory(context.runtime.cwd, context.runtime.env)}`;
-	const rows = details.firstDeploy ? [
-		{
-			label: "Workspace",
-			value: details.workspaceName
-		},
-		{
-			label: "Project",
-			value: details.projectName,
-			origin: details.projectAnnotation
-		},
-		{
-			label: "Branch",
-			value: details.branchName,
-			origin: details.branchAnnotation
-		},
-		{
-			label: "App",
-			value: details.appName,
-			origin: details.appAnnotation
-		},
-		{
-			label: "Framework",
-			value: details.framework.displayName,
-			origin: details.framework.annotation
-		},
-		{
-			label: "Runtime",
-			value: `HTTP ${details.runtime.port}`,
-			origin: details.runtime.annotation
-		}
-	] : [];
-	const lines = [
-		title,
-		"",
-		...renderDeployOutputRows(context.ui, rows),
-		""
-	];
-	context.output.stderr.write(`${lines.join("\n")}\n`);
+	const prefix = details.includeDirectory ? `Deploying ${directory} to` : "Deploying to";
+	context.output.stderr.write(`${prefix} ${details.projectName} / ${details.branchName} / ${details.appName}\n\n`);
 }
-function maybeRenderLocalPinBound(context, projectName) {
+function maybeRenderProjectLinked(context, directory, projectName, localPinPath) {
 	if (context.flags.json || context.flags.quiet) return;
-	context.output.stderr.write(`This directory is now linked to project ${projectName}.\n\n`);
+	context.output.stderr.write(`${context.ui.success("✔")} Linked "${directory}" to Project "${projectName}"\nSaved ${localPinPath}\n\n`);
 }
 async function maybeCustomizeDeploySettings(context, options) {
 	if (!options.firstDeploy || context.flags.yes || options.explicitFramework || options.explicitBuildType || options.explicitHttpPort || !canPrompt(context)) return {
@@ -1659,19 +1695,6 @@ async function maybeCustomizeDeploySettings(context, options) {
 		runtime
 	};
 }
-function annotationForProjectResolution(resolution) {
-	switch (resolution.projectSource) {
-		case "explicit": return "set by --project";
-		case "env": return `from ${PRISMA_PROJECT_ID_ENV_VAR}`;
-		case "local-pin": return "from local pin";
-		case "created": return resolution.targetNameSource === "directory-name" ? "created from directory name" : "created from package.json";
-		case "package-name":
-		case "directory-name": return "linked to existing project";
-		case "platform-mapping":
-		case "remembered-local": return "linked to existing project";
-		case "prompt": return "selected by you";
-	}
-}
 function frameworkDisplayName(framework) {
 	switch (framework) {
 		case "nextjs": return "Next.js";
@@ -1692,15 +1715,6 @@ function formatDeployDirectory(cwd) {
 	const basename = path.basename(cwd);
 	return basename ? `./${basename}` : ".";
 }
-function formatLocalDirectory(cwd, env) {
-	const resolved = path.resolve(cwd);
-	const home = env.HOME ? path.resolve(env.HOME) : null;
-	if (home && (resolved === home || resolved.startsWith(`${home}${path.sep}`))) {
-		const relative = path.relative(home, resolved);
-		return relative ? `~/${relative}` : "~";
-	}
-	return resolved;
-}
 async function readCurrentWorkspaceId(context) {
 	const state = await context.stateStore.read();
 	if (state.auth?.workspaceId) return state.auth.workspaceId;
@@ -1835,52 +1849,31 @@ function readDeployEnvOverride(context, name) {
 	const value = context.runtime.env[name]?.trim();
 	return value ? value : void 0;
 }
-/**
-* `app deploy` falls into "create a new project on first deploy" when no
-* existing project matches the package.json name (or the cwd basename as a
-* fallback). When the create call fails the user often doesn't realise the
-* CLI was attempting to create a project at all — they thought the deploy
-* would find an existing project. Surface that context, and recommend the
-* explicit `--project` flag as the unambiguous way out.
-*/
-function createProjectOnFirstDeployError(options) {
-	const { error, inferredName, workspaceName } = options;
-	const status = extractHttpStatus(error);
-	const errorMessage = error instanceof Error ? error.message : String(error);
-	const inferredContext = `No existing project matched the package.json name \`${inferredName}\`, so the CLI attempted to create one.`;
-	const nextSteps = ["prisma-cli project list", "prisma-cli app deploy --project <id-or-name>"];
-	if (status === 401 || status === 403) return new CliError({
-		code: "AUTH_FORBIDDEN",
-		domain: "auth",
-		summary: "Could not create a new project for this deploy",
-		why: `${inferredContext} The platform rejected the create (HTTP ${status}).`,
-		fix: `Pass --project <id-or-name> to deploy into an existing project, or grant the service token project-create permission on workspace \`${workspaceName}\`.`,
-		debug: formatDebugDetails(error),
-		exitCode: 1,
-		nextSteps
-	});
+function projectSetupRequiredError(projects, suggestedName) {
+	const createCommand = `prisma-cli app deploy --create-project ${formatCommandArgument(suggestedName.name)}`;
 	return new CliError({
-		code: "DEPLOY_FAILED",
-		domain: "app",
-		summary: "Could not create a new project for this deploy",
-		why: `${inferredContext} ${errorMessage}`.trim(),
-		fix: "Pass --project <id-or-name> to deploy into an existing project, or retry after addressing the platform error above.",
-		debug: formatDebugDetails(error),
+		code: "PROJECT_SETUP_REQUIRED",
+		domain: "project",
+		summary: "Choose a Project before deploying this directory",
+		why: "This directory is not linked to a Prisma Project, and deploy will not choose or create one implicitly.",
+		fix: "Choose an existing Project with --project, create one with --create-project, or rerun interactively to pick from the setup list.",
+		meta: {
+			candidates: sortProjects(projects).map((project) => ({
+				id: project.id,
+				name: project.name
+			})),
+			suggestedProjectName: suggestedName.name,
+			suggestedProjectNameSource: suggestedName.source,
+			recoveryCommands: ["prisma-cli app deploy --project <id-or-name>", createCommand]
+		},
 		exitCode: 1,
-		nextSteps
+		nextSteps: [
+			"prisma-cli project list",
+			"prisma-cli app deploy --project <id-or-name>",
+			createCommand
+		]
 	});
 }
-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);
-		if (match) return Number.parseInt(match[1], 10);
-	}
-	return null;
-}
 function noDeploymentsError(summary, why) {
 	return new CliError({
 		code: "NO_DEPLOYMENTS",

package/dist/controllers/project.js

@@ -1,8 +1,10 @@
-import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../shell/errors.js";
+import { CliError, authRequiredError, featureUnavailableError, 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 { resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
+import { bindProjectToDirectory, isValidProjectSetupName, projectCreateFailedError, projectSetupNameRequiredError, resolveProjectForSetup } from "../lib/project/setup.js";
+import { createPreviewAppProvider } from "../lib/app/preview-provider.js";
 import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
 import { parseGitHubRepositoryUrl, readGitOriginRemote } from "../adapters/git.js";
@@ -48,6 +50,44 @@ async function runProjectShow(context, explicitProject) {
 		nextSteps: []
 	};
 }
+async function runProjectCreate(context, projectName) {
+	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
+	if (!workspace) throw workspaceRequiredError();
+	if (!isValidProjectSetupName(projectName)) throw projectSetupNameRequiredError("project create");
+	if (!isRealMode(context)) throw featureUnavailableError("Project create is not available in fixture mode", "Creating Projects requires live platform integration.", "Rerun without fixture mode enabled to create a Project.", ["prisma-cli auth login"], "project");
+	const client = await requireComputeAuth(context.runtime.env);
+	if (!client) throw authRequiredError();
+	const provider = createPreviewAppProvider(client);
+	const name = projectName.trim();
+	const created = await provider.createProject({ name }).catch((error) => {
+		throw projectCreateFailedError(error, name, workspace, {
+			nextSteps: ["prisma-cli project list", "prisma-cli project link <id-or-name>"],
+			permissionFix: "Grant the token permission to create Projects in this workspace, or link an existing Project.",
+			fallbackFix: "Retry the command, or choose an existing Project with prisma-cli project link <id-or-name>."
+		});
+	});
+	return {
+		command: "project.create",
+		result: await bindProjectToDirectory(context, workspace, {
+			id: created.id,
+			name: created.name
+		}, "created"),
+		warnings: [],
+		nextSteps: ["prisma-cli app deploy"]
+	};
+}
+async function runProjectLink(context, projectRef) {
+	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
+	if (!workspace) throw workspaceRequiredError();
+	if (!projectRef || !projectRef.trim()) throw usageError("Project link requires a Project id or name", "The command cannot choose a Project without an explicit id or name.", "Pass the Project id or name as the first argument.", ["prisma-cli project link proj_123"], "project");
+	const projects = isRealMode(context) ? await listRealProjectsForLink(context, workspace) : listFixtureWorkspaceProjects(context, workspace);
+	return {
+		command: "project.link",
+		result: await bindProjectToDirectory(context, workspace, toProjectSummary(resolveProjectForSetup(projectRef.trim(), projects, workspace)), "linked"),
+		warnings: [],
+		nextSteps: ["prisma-cli app deploy"]
+	};
+}
 async function runGitConnect(context, gitUrl, options = {}) {
 	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
 	if (!workspace) throw workspaceRequiredError();
@@ -163,6 +203,11 @@ async function resolveProjectShowInRealMode(context, workspace, explicitProject)
 		remember: false
 	});
 }
+async function listRealProjectsForLink(context, workspace) {
+	const client = await requireComputeAuth(context.runtime.env);
+	if (!client) throw authRequiredError();
+	return listRealWorkspaceProjects(client, workspace);
+}
 async function resolveProjectShowInFixtureMode(context, workspace, explicitProject) {
 	return resolveProjectTarget({
 		context,
@@ -501,4 +546,4 @@ function toProjectSummary(project) {
 	};
 }
 //#endregion
-export { listRealWorkspaceProjects, runGitConnect, runGitDisconnect, runProjectList, runProjectShow };
+export { listRealWorkspaceProjects, runGitConnect, runGitDisconnect, runProjectCreate, runProjectLink, runProjectList, runProjectShow };

package/dist/lib/project/resolution.js

@@ -198,4 +198,4 @@ function toProjectSummary(project) {
 	};
 }
 //#endregion
-export { inferTargetName, projectNotFoundError, resolveProjectTarget, sortProjects };
+export { inferTargetName, projectAmbiguousError, projectNotFoundError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects };

package/dist/lib/project/setup.js

@@ -0,0 +1,86 @@
+import { CliError, usageError } from "../../shell/errors.js";
+import { projectAmbiguousError, projectNotFoundError } from "./resolution.js";
+import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, ensureLocalResolutionPinGitignore, writeLocalResolutionPin } from "./local-pin.js";
+//#region src/lib/project/setup.ts
+function isValidProjectSetupName(projectName) {
+	return projectName.trim().length > 0;
+}
+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);
+	throw projectNotFoundError(projectRef, workspace);
+}
+async function bindProjectToDirectory(context, workspace, project, action) {
+	await writeLocalResolutionPin(context.runtime.cwd, {
+		workspaceId: workspace.id,
+		projectId: project.id
+	});
+	await ensureLocalResolutionPinGitignore(context.runtime.cwd);
+	return {
+		workspace,
+		project,
+		directory: formatSetupDirectory(context.runtime.cwd),
+		localPin: {
+			path: LOCAL_RESOLUTION_PIN_RELATIVE_PATH,
+			written: true
+		},
+		action
+	};
+}
+function toProjectSummary(project) {
+	return {
+		id: project.id,
+		name: project.name
+	};
+}
+function projectSetupNameRequiredError(command) {
+	return usageError("Project create requires a name", "The project name must be a non-empty value.", "Pass a Project name explicitly.", [`prisma-cli ${command} my-app`], "project");
+}
+function projectCreateFailedError(error, projectName, workspace, options) {
+	const status = extractHttpStatus(error);
+	if (status === 401 || status === 403) return new CliError({
+		code: "PROJECT_CREATE_FAILED",
+		domain: "project",
+		summary: `Could not create Project "${projectName}"`,
+		why: `The platform rejected the Project create in workspace "${workspace.name}" (HTTP ${status}).`,
+		fix: options.permissionFix,
+		debug: formatDebugDetails(error),
+		exitCode: 1,
+		nextSteps: options.nextSteps
+	});
+	return new CliError({
+		code: "PROJECT_CREATE_FAILED",
+		domain: "project",
+		summary: `Could not create Project "${projectName}"`,
+		why: error instanceof Error ? error.message : String(error),
+		fix: options.fallbackFix,
+		debug: formatDebugDetails(error),
+		exitCode: 1,
+		nextSteps: options.nextSteps
+	});
+}
+function formatCommandArgument(value) {
+	return /^[A-Za-z0-9._/-]+$/.test(value) ? value : JSON.stringify(value);
+}
+function formatSetupDirectory(cwd) {
+	const basename = cwd.split(/[\\/]/).filter(Boolean).pop();
+	return basename ? `./${basename}` : ".";
+}
+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);
+		if (match) return Number.parseInt(match[1], 10);
+	}
+	return null;
+}
+function formatDebugDetails(error) {
+	if (error instanceof Error) return error.stack ?? error.message;
+	return typeof error === "string" ? error : null;
+}
+//#endregion
+export { bindProjectToDirectory, formatCommandArgument, isValidProjectSetupName, projectCreateFailedError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary };

package/dist/presenters/project.js

@@ -1,3 +1,4 @@
+import { renderSummaryLine } from "../shell/ui.js";
 import { renderList, renderMutate, renderShow, serializeList } from "../output/patterns.js";
 //#region src/presenters/project.ts
 function renderProjectList(context, descriptor, result) {
@@ -51,6 +52,14 @@ function renderProjectShow(context, descriptor, result) {
 function serializeProjectShow(result) {
 	return result;
 }
+function renderProjectSetup(context, _descriptor, result) {
+	const lines = result.action === "created" ? [renderSummaryLine(context.ui, "success", `Created Project "${result.project.name}"`)] : [];
+	lines.push(renderSummaryLine(context.ui, "success", `Linked "${result.directory}" to Project "${result.project.name}"`), `Saved ${result.localPin.path}`);
+	return lines;
+}
+function serializeProjectSetup(result) {
+	return result;
+}
 function renderGitConnect(context, descriptor, result) {
 	const connection = result.repositoryConnection;
 	return renderMutate({
@@ -124,4 +133,4 @@ function formatGitConnectionDetail(status) {
 	}
 }
 //#endregion
-export { renderGitConnect, renderGitDisconnect, renderProjectList, renderProjectShow, serializeProjectList, serializeProjectShow };
+export { renderGitConnect, renderGitDisconnect, renderProjectList, renderProjectSetup, renderProjectShow, serializeProjectList, serializeProjectSetup, serializeProjectShow };

package/dist/shell/command-meta.js

@@ -54,7 +54,11 @@ const DESCRIPTORS = [
 		id: "project",
 		path: ["prisma", "project"],
 		description: "Manage and inspect your Prisma projects",
-		examples: ["prisma-cli project list", "prisma-cli project show"]
+		examples: [
+			"prisma-cli project list",
+			"prisma-cli project link proj_123",
+			"prisma-cli project create my-app"
+		]
 	},
 	{
 		id: "app",
@@ -94,6 +98,26 @@ const DESCRIPTORS = [
 		description: "Show which project is active for this directory",
 		examples: ["prisma-cli project show", "prisma-cli project show --project proj_123 --json"]
 	},
+	{
+		id: "project.create",
+		path: [
+			"prisma",
+			"project",
+			"create"
+		],
+		description: "Create a Project and link this directory",
+		examples: ["prisma-cli project create my-app", "prisma-cli project create my-app --json"]
+	},
+	{
+		id: "project.link",
+		path: [
+			"prisma",
+			"project",
+			"link"
+		],
+		description: "Link this directory to an existing Project",
+		examples: ["prisma-cli project link proj_123", "prisma-cli project link \"Acme Dashboard\" --json"]
+	},
 	{
 		id: "git.connect",
 		path: [
@@ -183,6 +207,8 @@ const DESCRIPTORS = [
 		longDescription: "Agent skills for guided Next.js deploys are available from the Prisma CLI skill cluster.",
 		examples: [
 			"prisma-cli app deploy",
+			"prisma-cli app deploy --project proj_123",
+			"prisma-cli app deploy --create-project my-app --yes",
 			"prisma-cli app deploy --app my-app --env DATABASE_URL=postgresql://example",
 			"prisma-cli app deploy --app my-app --framework nextjs --http-port 3000",
 			"prisma-cli app deploy --branch feat-login --framework hono",

package/package.json

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