@prisma/cli 3.0.0-alpha.9 → 3.0.0-beta.1

package/dist/controllers/project.js

@@ -1,8 +1,13 @@
-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 { 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 { promptForProjectSetupChoice } from "../lib/project/interactive-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";
@@ -14,6 +19,12 @@ const GITHUB_INSTALL_POLL_TIMEOUT_MS = 12e4;
 function isRealMode(context) {
 	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
 }
+async function readProjectListLocalBinding(cwd, workspace, projects) {
+	const pin = await readLocalResolutionPin(cwd);
+	if (pin.kind === "present") return pin.pin.workspaceId === workspace.id && projects.some((project) => project.id === pin.pin.projectId) ? { status: "linked" } : { status: "invalid" };
+	if (pin.kind === "invalid") return { status: "invalid" };
+	return { status: "not-linked" };
+}
 async function runProjectList(context) {
 	const authState = await requireAuthenticatedAuthState(context);
 	const workspace = authState.workspace;
@@ -21,40 +32,171 @@ async function runProjectList(context) {
 	if (isRealMode(context)) {
 		const client = await requireComputeAuth(context.runtime.env);
 		if (!client) throw authRequiredError();
+		const projects = sortProjects(await listRealWorkspaceProjects(client, workspace));
+		const localBinding = await readProjectListLocalBinding(context.runtime.cwd, workspace, projects);
+		const nextActions = buildProjectListNextActions(localBinding);
 		return {
 			command: "project.list",
 			result: {
 				workspace,
-				projects: sortProjects(await listRealWorkspaceProjects(client, workspace)).map(toProjectSummary)
+				projects: projects.map(toProjectSummary),
+				localBinding
 			},
 			warnings: [],
-			nextSteps: []
+			nextSteps: [],
+			nextActions
 		};
 	}
+	const result = await createProjectUseCases(createCliUseCaseGateways(context)).list(authState);
+	const localBinding = await readProjectListLocalBinding(context.runtime.cwd, workspace, result.projects);
+	const nextActions = buildProjectListNextActions(localBinding);
 	return {
 		command: "project.list",
-		result: await createProjectUseCases(createCliUseCaseGateways(context)).list(authState),
+		result: {
+			...result,
+			localBinding
+		},
 		warnings: [],
-		nextSteps: []
+		nextSteps: [],
+		nextActions
 	};
 }
+function buildProjectListNextActions(localBinding) {
+	return localBinding?.status === "linked" ? [] : buildProjectSetupNextActions({
+		createCommand: "prisma-cli project create <name>",
+		reason: localBinding?.status === "invalid" ? "This directory has an invalid local Project binding. Ask the user which Prisma Project to link before running Project-scoped commands." : "This directory is not linked to a Prisma Project. Project list shows available Projects, but none is selected for this directory."
+	});
+}
 async function runProjectShow(context, explicitProject) {
 	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
 	if (!workspace) throw workspaceRequiredError();
+	const result = isRealMode(context) ? await resolveProjectShowInRealMode(context, workspace, explicitProject) : await resolveProjectShowInFixtureMode(context, workspace, explicitProject);
 	return {
 		command: "project.show",
-		result: isRealMode(context) ? await resolveProjectShowInRealMode(context, workspace, explicitProject) : await resolveProjectShowInFixtureMode(context, workspace, explicitProject),
+		result,
 		warnings: [],
-		nextSteps: []
+		nextSteps: [],
+		nextActions: result.project === null ? buildProjectSetupNextActions({
+			commandName: "project show",
+			suggestedProjectName: result.suggestedProjectName,
+			reason: "This directory is not linked to a Prisma Project. Package and directory names can suggest setup defaults, but they do not select a Project."
+		}) : []
+	};
+}
+async function runProjectCreate(context, projectName) {
+	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();
+	let provider = null;
+	let projects;
+	if (isRealMode(context)) {
+		const client = await requireComputeAuth(context.runtime.env);
+		if (!client) throw authRequiredError();
+		provider = createPreviewAppProvider(client);
+		projects = await listRealWorkspaceProjects(client, workspace);
+	} else projects = listFixtureWorkspaceProjects(context, workspace);
+	let result;
+	if (projectRef?.trim()) result = await bindProjectToDirectory(context, workspace, toProjectSummary(resolveProjectForSetup(projectRef.trim(), projects, workspace)), "linked");
+	else if (canPrompt(context) && !context.flags.yes) result = await resolveInteractiveProjectLinkSetup(context, workspace, projects, provider);
+	else throw await projectLinkTargetRequiredError(context, projects);
+	return {
+		command: "project.link",
+		result,
+		warnings: [],
+		nextSteps: ["prisma-cli app deploy"]
+	};
+}
+async function resolveInteractiveProjectLinkSetup(context, workspace, projects, provider) {
+	const setup = await promptForProjectSetupChoice({
+		context,
+		projects,
+		createProject: (projectName) => {
+			if (!provider) 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");
+			return createProjectForLinkSetup(provider, projectName, workspace);
+		},
+		cancel: {
+			why: "Project link needs a Project before it can continue.",
+			fix: "Choose an existing Project or create a new one, then rerun project link.",
+			nextSteps: ["prisma-cli project link <id-or-name>", "prisma-cli project create <name>"]
+		}
+	});
+	return bindProjectToDirectory(context, workspace, setup.project, setup.action);
+}
+async function createProjectForLinkSetup(provider, projectName, workspace) {
+	const created = await provider.createProject({ name: projectName }).catch((error) => {
+		throw projectCreateFailedError(error, projectName, workspace, {
+			nextSteps: [
+				"prisma-cli project list",
+				"prisma-cli project link <id-or-name>",
+				`prisma-cli project create ${formatCommandArgument(projectName)}`
+			],
+			permissionFix: "Grant the token permission to create Projects in this workspace, or link an existing Project.",
+			fallbackFix: "Retry the command, or choose an existing Project with prisma-cli project link <id-or-name>."
+		});
+	});
+	return {
+		id: created.id,
+		name: created.name,
+		workspace
 	};
 }
+async function projectLinkTargetRequiredError(context, projects) {
+	const suggestedName = await inferTargetName(context.runtime.cwd);
+	const createCommand = `prisma-cli project create ${formatCommandArgument(suggestedName.name)}`;
+	const recoveryCommands = ["prisma-cli project link <id-or-name>", createCommand];
+	return new CliError({
+		code: "PROJECT_LINK_TARGET_REQUIRED",
+		domain: "project",
+		summary: "Choose a Project to link this directory",
+		why: "This directory is not linked to a Prisma Project. Existing Projects are candidates until the user chooses one, and package or directory names are suggestions only.",
+		fix: "Run prisma-cli project link in a TTY to choose from the setup list, pass a Project id or name, or create a new Project.",
+		meta: {
+			suggestedProjectName: suggestedName.name,
+			suggestedProjectNameSource: suggestedName.source,
+			candidates: sortProjects(projects).map(toProjectSummary),
+			recoveryCommands
+		},
+		exitCode: 2,
+		nextSteps: ["prisma-cli project list", ...recoveryCommands],
+		nextActions: buildProjectSetupNextActions({
+			suggestedProjectName: suggestedName.name,
+			createCommand,
+			reason: "Project link needs the user to choose an existing Project or create a new one. Existing Projects, package names, and directory names are candidates only, not selections."
+		})
+	});
+}
 async function runGitConnect(context, gitUrl, options = {}) {
 	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
 	if (!workspace) throw workspaceRequiredError();
 	if (isRealMode(context)) {
 		const client = await requireComputeAuth(context.runtime.env);
 		if (!client) throw authRequiredError();
-		const target = await resolveProjectShowInRealMode(context, workspace, options.project);
+		const target = await resolveRequiredProjectInRealMode(context, workspace, options.project, "git connect");
 		const repository = await resolveRepositoryForConnect(context, gitUrl);
 		const api = client;
 		const existing = await readFirstSourceRepository(api, target.project.id);
@@ -89,7 +231,7 @@ async function runGitConnect(context, gitUrl, options = {}) {
 			nextSteps: []
 		};
 	}
-	const target = await resolveProjectShowInFixtureMode(context, workspace, options.project);
+	const target = await resolveRequiredProjectInFixtureMode(context, workspace, options.project, "git connect");
 	const repository = await resolveRepositoryForConnect(context, gitUrl);
 	const existingConnection = await context.stateStore.readRepositoryConnection(target.project.id);
 	if (existingConnection) {
@@ -122,7 +264,7 @@ async function runGitDisconnect(context, options = {}) {
 	if (isRealMode(context)) {
 		const client = await requireComputeAuth(context.runtime.env);
 		if (!client) throw authRequiredError();
-		const target = await resolveProjectShowInRealMode(context, workspace, options.project);
+		const target = await resolveRequiredProjectInRealMode(context, workspace, options.project, "git disconnect");
 		const api = client;
 		const existing = await readFirstSourceRepository(api, target.project.id);
 		if (!existing) throw repoNotConnectedError();
@@ -138,7 +280,7 @@ async function runGitDisconnect(context, options = {}) {
 			nextSteps: []
 		};
 	}
-	const target = await resolveProjectShowInFixtureMode(context, workspace, options.project);
+	const target = await resolveRequiredProjectInFixtureMode(context, workspace, options.project, "git disconnect");
 	const existingConnection = await context.stateStore.readRepositoryConnection(target.project.id);
 	if (!existingConnection) throw repoNotConnectedError();
 	await context.stateStore.clearRepositoryConnection(target.project.id);
@@ -153,6 +295,17 @@ async function runGitDisconnect(context, options = {}) {
 	};
 }
 async function resolveProjectShowInRealMode(context, workspace, explicitProject) {
+	const client = await requireComputeAuth(context.runtime.env);
+	if (!client) throw authRequiredError();
+	return inspectProjectBinding({
+		context,
+		workspace,
+		explicitProject,
+		listProjects: () => listRealWorkspaceProjects(client, workspace),
+		commandName: "project show"
+	});
+}
+async function resolveRequiredProjectInRealMode(context, workspace, explicitProject, commandName) {
 	const client = await requireComputeAuth(context.runtime.env);
 	if (!client) throw authRequiredError();
 	return resolveProjectTarget({
@@ -160,16 +313,25 @@ async function resolveProjectShowInRealMode(context, workspace, explicitProject)
 		workspace,
 		explicitProject,
 		listProjects: () => listRealWorkspaceProjects(client, workspace),
-		remember: false
+		commandName
 	});
 }
 async function resolveProjectShowInFixtureMode(context, workspace, explicitProject) {
+	return inspectProjectBinding({
+		context,
+		workspace,
+		explicitProject,
+		listProjects: async () => listFixtureWorkspaceProjects(context, workspace),
+		commandName: "project show"
+	});
+}
+async function resolveRequiredProjectInFixtureMode(context, workspace, explicitProject, commandName) {
 	return resolveProjectTarget({
 		context,
 		workspace,
 		explicitProject,
 		listProjects: async () => listFixtureWorkspaceProjects(context, workspace),
-		remember: false
+		commandName
 	});
 }
 async function listRealWorkspaceProjects(client, workspace) {
@@ -494,11 +656,5 @@ function repoConnectionFixForStatus(status) {
 	if (status === 422) return "Make sure the GitHub App installation has access to this repository.";
 	return "Re-run with --trace for the underlying API response details.";
 }
-function toProjectSummary(project) {
-	return {
-		id: project.id,
-		name: project.name
-	};
-}
 //#endregion
-export { listRealWorkspaceProjects, runGitConnect, runGitDisconnect, runProjectList, runProjectShow };
+export { listRealWorkspaceProjects, runGitConnect, runGitDisconnect, runProjectCreate, runProjectLink, runProjectList, runProjectShow };

package/dist/lib/app/domain-guidance.js

@@ -0,0 +1,14 @@
+//#region src/lib/app/domain-guidance.ts
+function formatDomainFailureFix(domain) {
+	if (domain.status !== "failed") return null;
+	const dnsRecord = domain.dnsRecords[0];
+	if (domain.failureCategory === "dns") {
+		if (dnsRecord) return `Add ${dnsRecord.type} ${dnsRecord.name} -> ${dnsRecord.value}, then run prisma-cli app domain retry ${domain.hostname}.`;
+		return `DNS verification failed, but the platform did not return a DNS record. Run prisma-cli app domain show ${domain.hostname} later, then retry when the DNS target is available.`;
+	}
+	if (domain.failureCategory === "acme") return `Retry TLS issuance with prisma-cli app domain retry ${domain.hostname}. Contact support if it fails again.`;
+	if (domain.failureCategory === "storage") return `Retry provisioning with prisma-cli app domain retry ${domain.hostname}. Contact support if it fails again.`;
+	return `Run prisma-cli app domain retry ${domain.hostname}. Contact support if it fails again.`;
+}
+//#endregion
+export { formatDomainFailureFix };

package/dist/lib/app/env-config.js

@@ -3,10 +3,11 @@ import { usageError } from "../../shell/errors.js";
 const VALID_ROLES = new Set(["production", "preview"]);
 function positionalHint(command) {
 	if (command === "add" || command === "update") return "KEY=value ";
-	if (command === "rm") return "KEY ";
+	if (command === "remove") return "KEY ";
 	return "";
 }
 function resolveEnvScope(flags, options) {
+	if (flags.roleName && flags.branchName) throw usageError(`prisma-cli project env ${options.command} accepts either --role or --branch`, "--role targets a project-level config map; --branch targets a preview branch override.", "Pass exactly one scope flag.", [`prisma-cli project env ${options.command} ${positionalHint(options.command)}--role preview`, `prisma-cli project env ${options.command} ${positionalHint(options.command)}--branch feature/foo`], "app");
 	if (flags.roleName) {
 		if (!VALID_ROLES.has(flags.roleName)) throw usageError(`Unknown role "${flags.roleName}"`, "--role accepts production or preview.", "Pass --role production or --role preview.", [`prisma-cli project env ${options.command} --role production`, `prisma-cli project env ${options.command} --role preview`], "app");
 		return {
@@ -14,9 +15,17 @@ function resolveEnvScope(flags, options) {
 			role: flags.roleName
 		};
 	}
+	if (flags.branchName) return {
+		kind: "branch",
+		branchName: flags.branchName
+	};
 	if (options.requireExplicit) {
 		const positional = positionalHint(options.command);
-		throw usageError(`prisma-cli project env ${options.command} requires --role`, "Writing without an explicit scope is rejected so the command never silently targets production.", "Pass --role production or --role preview.", [`prisma-cli project env ${options.command} ${positional}--role production`, `prisma-cli project env ${options.command} ${positional}--role preview`], "app");
+		throw usageError(`prisma-cli project env ${options.command} requires --role or --branch`, "Writing without an explicit scope is rejected so the command never silently targets production.", "Pass --role production, --role preview, or --branch <git-name>.", [
+			`prisma-cli project env ${options.command} ${positional}--role production`,
+			`prisma-cli project env ${options.command} ${positional}--role preview`,
+			`prisma-cli project env ${options.command} ${positional}--branch feature/foo`
+		], "app");
 	}
 	return null;
 }
@@ -38,7 +47,7 @@ function parseKeyValuePositional(raw, command, env = process.env) {
 	const key = raw.slice(0, separatorIndex);
 	const value = raw.slice(separatorIndex + 1);
 	validateKey(key, command);
-	if (value.length === 0) throw usageError(`KEY=VALUE argument has an empty value`, `"${raw}" has an empty value after the = separator.`, `Pass a non-empty value, or use prisma-cli project env rm to remove a variable.`, [`prisma-cli project env ${command} ${key}=value --role production`], "app");
+	if (value.length === 0) throw usageError(`KEY=VALUE argument has an empty value`, `"${raw}" has an empty value after the = separator.`, `Pass a non-empty value, or use prisma-cli project env remove to remove a variable.`, [`prisma-cli project env ${command} ${key}=value --role production`], "app");
 	return {
 		key,
 		value
@@ -46,12 +55,13 @@ function parseKeyValuePositional(raw, command, env = process.env) {
 }
 const KEY_SHAPE = /^[A-Z_][A-Z0-9_]*$/;
 function validateKey(key, command) {
-	if (key.length === 0) throw usageError(`Variable key cannot be empty`, "An empty key was passed.", "Pass an env-var key, e.g. STRIPE_KEY.", [`prisma-cli project env ${command} STRIPE_KEY${command === "rm" ? "" : "=value"} --role production`], "app");
+	if (key.length === 0) throw usageError(`Variable key cannot be empty`, "An empty key was passed.", "Pass an env-var key, e.g. STRIPE_KEY.", [`prisma-cli project env ${command} STRIPE_KEY${command === "remove" ? "" : "=value"} --role production`], "app");
 	if (key.length > 256) throw usageError(`Variable key "${key}" exceeds the 256-character limit`, "Env-var keys are capped at 256 characters by the platform.", "Use a shorter key.", [], "app");
-	if (!KEY_SHAPE.test(key)) throw usageError(`Variable key "${key}" must match the POSIX env-var shape`, "Keys must start with an uppercase letter or underscore and contain only uppercase letters, digits, and underscores.", "Rename the key to match [A-Z_][A-Z0-9_]*.", [`prisma-cli project env ${command} STRIPE_KEY${command === "rm" ? "" : "=value"} --role production`], "app");
+	if (!KEY_SHAPE.test(key)) throw usageError(`Variable key "${key}" must match the POSIX env-var shape`, "Keys must start with an uppercase letter or underscore and contain only uppercase letters, digits, and underscores.", "Rename the key to match [A-Z_][A-Z0-9_]*.", [`prisma-cli project env ${command} STRIPE_KEY${command === "remove" ? "" : "=value"} --role production`], "app");
 }
 function formatScopeLabel(scope) {
-	return scope.role;
+	if (scope.kind === "role") return scope.role;
+	return `branch:${scope.branchName}`;
 }
 //#endregion
 export { formatScopeLabel, parseKeyValuePositional, resolveEnvScope };

package/dist/lib/app/preview-build.js

@@ -46,7 +46,7 @@ async function executePreviewBuild(options) {
 	});
 	const artifact = await strategy.execute();
 	try {
-		if (buildType === "nextjs") await restageNextjsArtifact(artifact.directory, options.appPath);
+		if (buildType === "nextjs") await restageNextjsArtifact(artifact, options.appPath);
 		await normalizeArtifactSymlinks(artifact.directory, options.appPath);
 		return {
 			artifact,
@@ -114,8 +114,10 @@ async function stageNextjsStandaloneArtifact(options) {
 		appRoot,
 		sourceRoot: await resolveSourceRoot(appRoot)
 	});
+	await hoistPnpmDependencies(path.join(artifactRoot, "node_modules"));
 }
-async function restageNextjsArtifact(artifactDir, appPath) {
+async function restageNextjsArtifact(artifact, appPath) {
+	const artifactDir = artifact.directory;
 	const standaloneDir = path.join(appPath, ".next", "standalone");
 	await rm(artifactDir, {
 		recursive: true,
@@ -126,17 +128,52 @@ async function restageNextjsArtifact(artifactDir, appPath) {
 		artifactDir,
 		appPath
 	});
+	const serverSubpath = nextjsServerSubpath(artifact.entrypoint);
+	const serverDir = serverSubpath ? path.join(artifactDir, serverSubpath) : artifactDir;
 	const publicDir = path.join(appPath, "public");
-	if (await directoryExists(publicDir)) await cp(publicDir, path.join(artifactDir, "public"), {
+	if (await directoryExists(publicDir)) await cp(publicDir, path.join(serverDir, "public"), {
 		recursive: true,
 		verbatimSymlinks: true
 	});
 	const staticDir = path.join(appPath, ".next", "static");
-	if (await directoryExists(staticDir)) await cp(staticDir, path.join(artifactDir, ".next", "static"), {
+	if (await directoryExists(staticDir)) await cp(staticDir, path.join(serverDir, ".next", "static"), {
 		recursive: true,
 		verbatimSymlinks: true
 	});
 }
+function nextjsServerSubpath(entrypoint) {
+	const dir = path.posix.dirname(entrypoint);
+	return dir === "." ? "" : dir;
+}
+async function hoistPnpmDependencies(nodeModulesDir) {
+	const pnpmNodeModulesDir = path.join(nodeModulesDir, ".pnpm", "node_modules");
+	if (!await directoryExists(pnpmNodeModulesDir)) return;
+	const entries = await readdir(pnpmNodeModulesDir, { withFileTypes: true });
+	for (const entry of entries) {
+		const sourcePath = path.join(pnpmNodeModulesDir, entry.name);
+		if (entry.name.startsWith("@") && entry.isDirectory()) {
+			const scopedEntries = await readdir(sourcePath, { withFileTypes: true });
+			for (const scopedEntry of scopedEntries) {
+				const scopedDestination = path.join(nodeModulesDir, entry.name, scopedEntry.name);
+				if (await pathExists(scopedDestination)) continue;
+				await mkdir(path.dirname(scopedDestination), { recursive: true });
+				await copyPathMaterializingSymlinks(path.join(sourcePath, scopedEntry.name), scopedDestination, {
+					standaloneRoot: pnpmNodeModulesDir,
+					appRoot: nodeModulesDir,
+					sourceRoot: nodeModulesDir
+				});
+			}
+			continue;
+		}
+		const destinationPath = path.join(nodeModulesDir, entry.name);
+		if (await pathExists(destinationPath)) continue;
+		await copyPathMaterializingSymlinks(sourcePath, destinationPath, {
+			standaloneRoot: pnpmNodeModulesDir,
+			appRoot: nodeModulesDir,
+			sourceRoot: nodeModulesDir
+		});
+	}
+}
 async function normalizeArtifactSymlinks(artifactDir, appPath) {
 	const normalizedArtifactDir = path.resolve(artifactDir);
 	const normalizedAppPath = path.resolve(appPath);
@@ -174,7 +211,9 @@ function isPathWithin(rootPath, candidatePath) {
 async function copyPathMaterializingSymlinks(sourcePath, destinationPath, options) {
 	const sourceStat = await lstat(sourcePath);
 	if (sourceStat.isSymbolicLink()) {
-		await copyPathMaterializingSymlinks(await resolveSymlinkTarget(sourcePath, options), destinationPath, options);
+		const resolvedTarget = await resolveSymlinkTarget(sourcePath, options);
+		if (resolvedTarget === null) return;
+		await copyPathMaterializingSymlinks(resolvedTarget, destinationPath, options);
 		return;
 	}
 	if (sourceStat.isDirectory()) {
@@ -200,8 +239,14 @@ async function resolveSymlinkTarget(symlinkPath, options) {
 		const fallbackTarget = path.join(options.appRoot, path.relative(options.standaloneRoot, resolvedTarget));
 		if (await pathExists(fallbackTarget)) return fallbackTarget;
 	}
+	if (isPnpmHoistLink(symlinkPath)) return null;
 	throw new Error(`Next.js standalone symlink target is missing: ${symlinkPath} -> ${linkTarget} (resolved to ${resolvedTarget})`);
 }
+function isPnpmHoistLink(symlinkPath) {
+	const parts = path.dirname(symlinkPath).split(path.sep);
+	for (let i = 0; i < parts.length - 1; i++) if (parts[i] === ".pnpm" && parts[i + 1] === "node_modules") return true;
+	return false;
+}
 async function pathExists(targetPath) {
 	try {
 		await stat(targetPath);

package/dist/lib/app/preview-progress.js

@@ -96,29 +96,5 @@ function createPreviewPromoteProgress(output, enabled) {
 		}
 	};
 }
-function createPreviewUpdateEnvProgress(output, enabled) {
-	if (!enabled) return;
-	const write = (line) => {
-		output.write(`${line}\n`);
-	};
-	return {
-		onVersionCreated(versionId) {
-			write(`Creating updated deployment ${versionId}...`);
-		},
-		onStartRequested() {
-			write("Starting deployment...");
-		},
-		onStatusChange(status) {
-			write(`Status: ${status}`);
-		},
-		onRunning(url) {
-			if (url) {
-				write(`Deployment is running at ${url}.`);
-				return;
-			}
-			write("Deployment is running.");
-		}
-	};
-}
 //#endregion
-export { createPreviewDeployProgress, createPreviewDeployProgressState, createPreviewPromoteProgress, createPreviewUpdateEnvProgress };
+export { createPreviewDeployProgress, createPreviewDeployProgressState, createPreviewPromoteProgress };

package/dist/lib/app/preview-provider.js

@@ -3,6 +3,18 @@ import { PreviewBuildStrategy } from "./preview-build.js";
 import path from "node:path";
 import { ApiError, CancelledError, ComputeClient, streamLogs } from "@prisma/compute-sdk";
 //#region src/lib/app/preview-provider.ts
+var PreviewDomainApiError = class extends Error {
+	status;
+	code;
+	hint;
+	constructor(options) {
+		super(`${options.summary}: ${options.message}${options.hint ? ` ${options.hint}` : ""}`);
+		this.name = "PreviewDomainApiError";
+		this.status = options.status;
+		this.code = options.code ?? null;
+		this.hint = options.hint ?? null;
+	}
+};
 function createPreviewAppProvider(client, options) {
 	const sdk = new ComputeClient(client);
 	return {
@@ -35,6 +47,43 @@ function createPreviewAppProvider(client, options) {
 				name: appResult.value.name
 			};
 		},
+		async listDomains(appId) {
+			return listComputeServiceDomains(client, appId);
+		},
+		async addDomain(options) {
+			const result = await client.POST("/v1/compute-services/{computeServiceId}/domains", {
+				params: { path: { computeServiceId: options.appId } },
+				body: { hostname: options.hostname }
+			});
+			if (result.error || !result.data) {
+				if (result.response.status === 409) {
+					const existing = (await listComputeServiceDomains(client, options.appId)).find((domain) => sameHostname(domain.hostname, options.hostname));
+					if (existing) return {
+						domain: existing,
+						existing: true
+					};
+				}
+				throw domainApiCallError("Failed to add custom domain", result.response, result.error);
+			}
+			return {
+				domain: normalizeDomainRecord(result.data.data),
+				existing: false
+			};
+		},
+		async showDomain(domainId) {
+			const result = await client.GET("/v1/domains/{domainId}", { params: { path: { domainId } } });
+			if (result.error || !result.data) throw domainApiCallError("Failed to show custom domain", result.response, result.error);
+			return normalizeDomainRecord(result.data.data);
+		},
+		async removeDomain(domainId) {
+			const result = await client.DELETE("/v1/domains/{domainId}", { params: { path: { domainId } } });
+			if (result.error) throw domainApiCallError("Failed to remove custom domain", result.response, result.error);
+		},
+		async retryDomain(domainId) {
+			const result = await client.POST("/v1/domains/{domainId}/retry", { params: { path: { domainId } } });
+			if (result.error || !result.data) throw domainApiCallError("Failed to retry custom domain", result.response, result.error);
+			return normalizeDomainRecord(result.data.data);
+		},
 		async promoteDeployment(options) {
 			const promoteResult = await sdk.promote({
 				serviceId: options.appId,
@@ -263,6 +312,46 @@ async function listComputeServices(client, options) {
 		liveUrl: toAbsoluteUrl(service.serviceEndpointDomain ?? null)
 	}));
 }
+async function listComputeServiceDomains(client, computeServiceId) {
+	const result = await client.GET("/v1/compute-services/{computeServiceId}/domains", { params: { path: { computeServiceId } } });
+	if (result.error || !result.data) throw domainApiCallError("Failed to list custom domains", result.response, result.error);
+	return result.data.data.map((domain) => normalizeDomainRecord(domain));
+}
+function normalizeDomainRecord(domain) {
+	return {
+		id: domain.id,
+		type: domain.type,
+		url: domain.url,
+		hostname: domain.hostname,
+		computeServiceId: domain.computeServiceId,
+		status: domain.status,
+		foundryStatus: domain.foundryStatus,
+		failureReason: domain.failureReason,
+		failureCategory: domain.failureCategory,
+		certExpiresAt: domain.certExpiresAt,
+		createdAt: domain.createdAt,
+		updatedAt: domain.updatedAt,
+		dnsRecords: normalizeDomainDnsRecords(domain.dnsRecords)
+	};
+}
+function normalizeDomainDnsRecords(records) {
+	if (!Array.isArray(records)) return [];
+	return records.map((record) => {
+		if (typeof record.type !== "string" || typeof record.name !== "string" || typeof record.value !== "string") return null;
+		return {
+			type: record.type,
+			name: record.name,
+			value: record.value,
+			ttl: typeof record.ttl === "number" ? record.ttl : null
+		};
+	}).filter((record) => Boolean(record));
+}
+function sameHostname(left, right) {
+	return normalizeHostnameForComparison(left) === normalizeHostnameForComparison(right);
+}
+function normalizeHostnameForComparison(hostname) {
+	return hostname.trim().replace(/\.$/, "").toLowerCase();
+}
 async function createBranchApp(client, options) {
 	const branch = await resolveOrCreateBranch(client, {
 		projectId: options.projectId,
@@ -301,6 +390,15 @@ function apiCallError(summary, response, error) {
 	const hint = error.error?.hint ? ` ${error.error.hint}` : "";
 	return /* @__PURE__ */ new Error(`${summary}: ${message}${hint}`);
 }
+function domainApiCallError(summary, response, error) {
+	return new PreviewDomainApiError({
+		summary,
+		status: response.status,
+		code: error.error?.code ?? null,
+		message: error.error?.message ?? `Management API returned HTTP ${response.status}.`,
+		hint: error.error?.hint ?? null
+	});
+}
 async function findAppForDeployment(sdk, deploymentId) {
 	const projectsResult = await sdk.listProjects();
 	if (projectsResult.isErr()) throw new Error(projectsResult.error.message);
@@ -330,4 +428,4 @@ function toAbsoluteUrl(url) {
 	return url.startsWith("https://") || url.startsWith("http://") ? url : `https://${url}`;
 }
 //#endregion
-export { createPreviewAppProvider };
+export { PreviewDomainApiError, createPreviewAppProvider };