@prisma/cli 3.0.0-beta.11 → 3.0.0-beta.13

package/dist/controllers/app.js

@@ -2,26 +2,27 @@ import { SERVICE_TOKEN_ENV_VAR, getApiBaseUrl } from "../lib/auth/client.js";
 import { FileTokenStorage } from "../adapters/token-storage.js";
 import { CliError, authRequiredError, featureUnavailableError, usageError, workspaceRequiredError } from "../shell/errors.js";
 import { confirmPrompt, selectPrompt, textPrompt } from "../shell/prompt.js";
+import { DEFAULT_REGION } from "../lib/app/app-interaction.js";
+import { PRISMA_APP_CONFIG_FILENAME, detectLegacyBuildSettings, resolveConfiguredAppBuildSettings, resolveInferredAppBuildSettings } from "../lib/app/build-settings.js";
+import { APP_BUILD_TYPES, RESOLVED_APP_BUILD_TYPES, executeAppBuild } from "../lib/app/build.js";
+import { envVarNames, parseEnvInputs } from "../lib/app/env-vars.js";
+import { DomainApiError, createAppProvider } from "../lib/app/app-provider.js";
 import { renderCommandHeader } from "../shell/ui.js";
 import { canPrompt } from "../shell/runtime.js";
 import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin } from "../lib/project/local-pin.js";
 import { formatCommandArgument } from "../shell/command-arguments.js";
-import { buildProjectSetupNextActions, inferTargetName, projectNotFoundError, projectResolutionErrorToCliError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
+import { buildProjectSetupNextActions, inferTargetName, localProjectWorkspaceMismatchError, projectNotFoundError, projectResolutionErrorToCliError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
 import { bindProjectToDirectory, projectCreateFailedError, projectDirectoryBindingErrorToCliError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
 import { maybeSetupBranchDatabase } from "../lib/app/branch-database-deploy.js";
 import { readBunPackageEntrypoint, readBunPackageJson } from "../lib/app/bun-project.js";
 import { COMPUTE_CONFIG_FILENAME as COMPUTE_CONFIG_FILENAME$1, ComputeConfigTargetRequiredError, computeConfigErrorToCliError, computeFrameworkToBuildType, computeTargetAppDir, inferComputeTargetFromCwd, loadComputeConfig as loadComputeConfig$1, mergeComputeDeployInputs, mergeComputeLocalInputs, selectComputeDeployTarget } from "../lib/app/compute-config.js";
 import { renderDeployOutputRows, renderDeploySettingsPreview } from "../lib/app/deploy-output.js";
 import { describeDeployAllFailure, perAppInputsForDeployAll, planAppDeploy } from "../lib/app/deploy-plan.js";
+import { createDeployProgress, createDeployProgressState, createPromoteProgress } from "../lib/app/deploy-progress.js";
 import { formatDomainFailureFix } from "../lib/app/domain-guidance.js";
-import { envVarNames, parseEnvInputs } from "../lib/app/env-vars.js";
 import { DEFAULT_LOCAL_DEV_PORT, runLocalApp } from "../lib/app/local-dev.js";
-import { PRISMA_APP_CONFIG_FILENAME, detectLegacyBuildSettings, resolveConfiguredPreviewBuildSettings, resolveInferredPreviewBuildSettings } from "../lib/app/preview-build-settings.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";
-import { PreviewDomainApiError, createPreviewAppProvider } from "../lib/app/preview-provider.js";
 import { enforceProductionDeployGate } from "../lib/app/production-deploy-gate.js";
+import { resolveReadBranch } from "../lib/app/read-branch.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
 import { readAuthState } from "../lib/auth/auth-ops.js";
 import { readLocalGitBranch } from "../lib/git/local-branch.js";
@@ -60,7 +61,7 @@ async function runAppBuild(context, options) {
 	}
 	assertSupportedEntrypoint(buildType, merged.entrypoint, "build");
 	if (compute.target?.build && buildType !== "auto") assertConfigBackedBuildSettings(buildType);
-	const buildSettings = compute.config && compute.target?.build && isConfigBackedBuildType(buildType) ? (await resolveConfiguredPreviewBuildSettings({
+	const buildSettings = compute.config && compute.target?.build && isConfigBackedBuildType(buildType) ? (await resolveConfiguredAppBuildSettings({
 		appPath: appDir,
 		buildType,
 		configured: compute.target.build,
@@ -68,7 +69,7 @@ async function runAppBuild(context, options) {
 		signal: context.runtime.signal
 	})).settings : void 0;
 	try {
-		const { artifact, buildType: actualBuildType } = await executePreviewBuild({
+		const { artifact, buildType: actualBuildType } = await executeAppBuild({
 			appPath: appDir,
 			entrypoint: merged.entrypoint,
 			buildType,
@@ -86,7 +87,7 @@ async function runAppBuild(context, options) {
 			nextSteps: ["prisma-cli app deploy"]
 		};
 	} catch (error) {
-		if (buildType === "auto" && isAutoBuildDetectionError(error)) throw usageError("App build requires an explicit framework when detection is ambiguous", `This preview auto-detects clear project shapes for ${RESOLVED_PREVIEW_BUILD_TYPES.map(formatBuildTypeName).join(", ")}.`, "Pass a supported --build-type value, or pass --entry <path> for a Bun app.", getBuildTypeExamples("build"), "app");
+		if (buildType === "auto" && isAutoBuildDetectionError(error)) throw usageError("App build requires an explicit framework when detection is ambiguous", `This preview auto-detects clear project shapes for ${RESOLVED_APP_BUILD_TYPES.map(formatBuildTypeName).join(", ")}.`, "Pass a supported --build-type value, or pass --entry <path> for a Bun app.", getBuildTypeExamples("build"), "app");
 		throw buildFailedError("Local app build failed", error);
 	}
 }
@@ -328,13 +329,13 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 	assertSupportedEntrypoint(buildType, merged.entrypoint?.value, "deploy");
 	const entrypoint = await resolveDeployEntrypoint(appDir, framework, merged.entrypoint?.value, context.runtime.signal);
 	if (computeConfig.target?.build) assertConfigBackedBuildSettings(buildType);
-	const buildSettingsResolution = computeConfig.config && computeConfig.target?.build && isConfigBackedBuildType(buildType) ? await resolveConfiguredPreviewBuildSettings({
+	const buildSettingsResolution = computeConfig.config && computeConfig.target?.build && isConfigBackedBuildType(buildType) ? await resolveConfiguredAppBuildSettings({
 		appPath: appDir,
 		buildType,
 		configured: computeConfig.target.build,
 		configPath: computeConfig.config.configPath,
 		signal: context.runtime.signal
-	}) : await resolveInferredPreviewBuildSettings({
+	}) : await resolveInferredAppBuildSettings({
 		appPath: appDir,
 		buildType,
 		signal: context.runtime.signal
@@ -348,7 +349,7 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 		firstProductionDeploy: productionDeployGate.firstProductionDeploy,
 		projectDir
 	});
-	const progressState = createPreviewDeployProgressState();
+	const progressState = createDeployProgressState();
 	const deployStartedAt = Date.now();
 	const deployResult = await provider.deployApp({
 		cwd: appDir,
@@ -364,7 +365,7 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 		envVars,
 		interaction: void 0,
 		signal: context.runtime.signal,
-		progress: createPreviewDeployProgress(context.output.stderr, context.ui, !context.flags.json && !context.flags.quiet, progressState)
+		progress: createDeployProgress(context.output.stderr, context.ui, !context.flags.json && !context.flags.quiet, progressState)
 	}).catch((error) => {
 		throw appDeployFailedError(error, progressState);
 	});
@@ -866,7 +867,7 @@ async function runAppPromote(context, deploymentId, appName, projectRef, configT
 		appId: selectedApp.id,
 		deploymentId: targetDeployment.id,
 		signal: context.runtime.signal,
-		progress: createPreviewPromoteProgress(context.output.stderr, !context.flags.json && !context.flags.quiet)
+		progress: createPromoteProgress(context.output.stderr, !context.flags.json && !context.flags.quiet)
 	}).catch((error) => {
 		throw deployFailedError("Failed to promote deployment", error, ["prisma-cli app list-deploys"]);
 	});
@@ -914,7 +915,7 @@ async function runAppRollback(context, appName, deploymentId, projectRef, config
 		appId: selectedApp.id,
 		deploymentId: targetDeployment.id,
 		signal: context.runtime.signal,
-		progress: createPreviewPromoteProgress(context.output.stderr, !context.flags.json && !context.flags.quiet)
+		progress: createPromoteProgress(context.output.stderr, !context.flags.json && !context.flags.quiet)
 	}).catch((error) => {
 		throw deployFailedError("Failed to roll back deployment", error, ["prisma-cli app list-deploys"]);
 	});
@@ -1106,7 +1107,7 @@ async function confirmDomainRemoval(context, target, hostname) {
 	})) throw usageError("Custom domain removal canceled", "The command was canceled before the domain was detached.", "Rerun the command and confirm removal, or pass --yes.", [`prisma-cli app domain remove ${hostname} --app ${target.app.name} --yes`], "app");
 }
 function domainCommandError(command, error, hostname) {
-	if (error instanceof PreviewDomainApiError) {
+	if (error instanceof DomainApiError) {
 		if (command === "add" && (error.status === 400 || error.status === 422) && isDomainDnsError(error)) return domainDnsNotConfiguredError(hostname, error);
 		if (command === "add" && error.status === 400) return new CliError({
 			code: "DOMAIN_HOSTNAME_INVALID",
@@ -1287,7 +1288,7 @@ async function resolveDeployAppSelection(context, projectId, apps, options) {
 		};
 		return {
 			appName: options.explicitAppName,
-			region: PREVIEW_DEFAULT_REGION,
+			region: DEFAULT_REGION,
 			displayName: options.explicitAppName,
 			annotation: "set by --app",
 			firstDeploy: options.firstDeploy
@@ -1316,7 +1317,7 @@ async function resolveDeployAppSelection(context, projectId, apps, options) {
 		};
 		return {
 			appName: configName.value,
-			region: PREVIEW_DEFAULT_REGION,
+			region: DEFAULT_REGION,
 			displayName: configName.value,
 			annotation: configName.annotation,
 			firstDeploy: options.firstDeploy
@@ -1334,7 +1335,7 @@ async function resolveDeployAppSelection(context, projectId, apps, options) {
 	};
 	return {
 		appName: inferredName.name,
-		region: PREVIEW_DEFAULT_REGION,
+		region: DEFAULT_REGION,
 		displayName: inferredName.name,
 		annotation: inferredName.source === "package-name" ? "created from package.json" : "created from directory name",
 		firstDeploy: options.firstDeploy
@@ -1366,7 +1367,7 @@ async function resolveAmbiguousDeployApp(context, matches, targetName, firstDepl
 		if (selected === cancel) throw usageError("App selection canceled", "The command was canceled before an app was selected.", "Re-run the command and choose an app, or pass --app <name>.", ["prisma-cli app deploy --app <name>"], "app");
 		if (selected === createNew) return {
 			appName: targetName,
-			region: PREVIEW_DEFAULT_REGION,
+			region: DEFAULT_REGION,
 			displayName: targetName,
 			annotation: "created from package.json",
 			firstDeploy
@@ -1531,7 +1532,7 @@ async function requirePreviewAppProviderWithClient(context) {
 	if (!client) throw authRequiredError(["prisma-cli auth login"]);
 	return {
 		client,
-		provider: createPreviewAppProvider(client, createPreviewLogAuthOptions(context.runtime.env, context.runtime.signal))
+		provider: createAppProvider(client, createPreviewLogAuthOptions(context.runtime.env, context.runtime.signal))
 	};
 }
 function createPreviewLogAuthOptions(env, signal) {
@@ -1584,13 +1585,18 @@ async function resolveProjectContext(context, client, explicitProject, options)
 	});
 	if (resolvedResult.isErr()) throw projectResolutionErrorToCliError(resolvedResult.error);
 	const resolved = resolvedResult.value;
-	const branch = options?.branch ?? await resolveDeployBranch(context, void 0);
+	const requested = options?.branch ?? await resolveDeployBranch(context, void 0);
+	const remoteBranch = options?.branch ? null : await resolveReadBranch(client, {
+		projectId: resolved.project.id,
+		branchName: requested.name,
+		signal: context.runtime.signal
+	});
 	return {
 		...resolved,
-		branch: {
+		branch: remoteBranch ?? {
 			id: null,
-			name: branch.name,
-			kind: toBranchKind(branch.name)
+			name: requested.name,
+			kind: toBranchKind(requested.name)
 		}
 	};
 }
@@ -1638,7 +1644,11 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 	}
 	const localPin = options.localPin;
 	if (localPin.kind === "present") {
-		if (localPin.pin.workspaceId !== workspace.id) throw localResolutionPinStaleError();
+		if (localPin.pin.workspaceId !== workspace.id) throw localProjectWorkspaceMismatchError({
+			pinnedWorkspaceId: localPin.pin.workspaceId,
+			pinnedProjectId: localPin.pin.projectId,
+			activeWorkspace: workspace
+		});
 		const project = projects.find((candidate) => candidate.id === localPin.pin.projectId);
 		if (!project) throw localResolutionPinStaleError();
 		return withRemoteDeployBranch(provider, {
@@ -2139,13 +2149,13 @@ async function readCurrentWorkspaceId(context) {
 function normalizeBuildType(requestedBuildType) {
 	if (!requestedBuildType) return "auto";
 	if (isPreviewBuildType(requestedBuildType)) return requestedBuildType;
-	throw usageError(`Unsupported build type "${requestedBuildType}"`, `Only ${PREVIEW_BUILD_TYPES.join(", ")} are supported in the current preview.`, "Pass a supported --build-type value.", getBuildTypeExamples("build"), "app");
+	throw usageError(`Unsupported build type "${requestedBuildType}"`, `Only ${APP_BUILD_TYPES.join(", ")} are supported in the current preview.`, "Pass a supported --build-type value.", getBuildTypeExamples("build"), "app");
 }
 function isPreviewBuildType(value) {
-	return PREVIEW_BUILD_TYPES.includes(value);
+	return APP_BUILD_TYPES.includes(value);
 }
 function getBuildTypeExamples(commandName) {
-	return RESOLVED_PREVIEW_BUILD_TYPES.map((buildType) => {
+	return RESOLVED_APP_BUILD_TYPES.map((buildType) => {
 		return `prisma-cli app ${commandName} --build-type ${buildType}${buildType === "bun" ? " --entry server.ts" : ""}`;
 	});
 }
@@ -2389,6 +2399,7 @@ function formatBuildTypeName(buildType) {
 		case "nextjs": return "Next.js";
 		case "nuxt": return "Nuxt";
 		case "astro": return "Astro";
+		case "nestjs": return "NestJS";
 		case "tanstack-start": return "TanStack Start";
 		case "bun": return "Bun";
 		case "auto": return "Auto";

package/dist/controllers/auth.js

@@ -1,4 +1,6 @@
-import { authRequiredError, usageError } from "../shell/errors.js";
+import { SERVICE_TOKEN_ENV_VAR } from "../lib/auth/client.js";
+import { FileTokenStorage, WorkspaceSelectionError } from "../adapters/token-storage.js";
+import { authRequiredError, usageError, workspaceAmbiguousError, workspaceNotAuthenticatedError, workspaceSwitchUnavailableError } from "../shell/errors.js";
 import { canPrompt } from "../shell/runtime.js";
 import { performLogin, performLogout, readAuthState } from "../lib/auth/auth-ops.js";
 import { createAuthUseCases } from "../use-cases/auth.js";
@@ -30,6 +32,40 @@ async function runAuthWhoAmI(context) {
 	else result = await createAuthUseCases(createCliUseCaseGateways(context)).whoami();
 	return createAuthSuccess("auth.whoami", result, result.authenticated ? [] : ["prisma-cli auth login"]);
 }
+async function runAuthWorkspaceList(context) {
+	const result = isRealMode(context) ? await listRealAuthWorkspaces(context) : await createAuthUseCases(createCliUseCaseGateways(context)).listWorkspaces();
+	return {
+		command: "auth.workspace.list",
+		result,
+		warnings: [],
+		nextSteps: result.workspaces.length === 0 ? ["prisma-cli auth login"] : []
+	};
+}
+async function runAuthWorkspaceUse(context, workspaceRef) {
+	if (!workspaceRef?.trim()) throw usageError("Workspace required", "auth workspace use needs a workspace id or cached workspace name.", "Pass a workspace from prisma-cli auth workspace list.", ["prisma-cli auth workspace list"], "auth");
+	return {
+		command: "auth.workspace.use",
+		result: isRealMode(context) ? await useRealAuthWorkspace(context, workspaceRef) : await createAuthUseCases(createCliUseCaseGateways(context)).useWorkspace(workspaceRef),
+		warnings: [],
+		nextSteps: ["prisma-cli auth whoami", "prisma-cli project list"]
+	};
+}
+async function runAuthWorkspaceSelect(context) {
+	return {
+		...await runAuthWorkspaceUse(context, await selectWorkspaceSession(context)),
+		command: "auth.workspace.select"
+	};
+}
+async function runAuthWorkspaceLogout(context, workspaceRef) {
+	if (!workspaceRef?.trim()) throw usageError("Workspace required", "auth workspace logout needs a workspace id or cached workspace name.", "Pass a workspace from prisma-cli auth workspace list.", ["prisma-cli auth workspace list"], "auth");
+	const result = isRealMode(context) ? await logoutRealAuthWorkspace(context, workspaceRef) : await createAuthUseCases(createCliUseCaseGateways(context)).logoutWorkspace(workspaceRef);
+	return {
+		command: "auth.workspace.logout",
+		result,
+		warnings: [],
+		nextSteps: result.activeWorkspace ? ["prisma-cli auth workspace list"] : ["prisma-cli auth workspace list", "prisma-cli auth workspace use <id>"]
+	};
+}
 async function requireAuthenticatedAuthState(context) {
 	if (isRealMode(context)) {
 		const current = await readAuthState(context.runtime.env, context.runtime.signal);
@@ -44,6 +80,108 @@ async function requireAuthenticatedAuthState(context) {
 	if (!canPrompt(context)) throw authRequiredError();
 	return loginWithSelectionFlow(context, useCases, {});
 }
+async function listRealAuthWorkspaces(context) {
+	const rawServiceToken = context.runtime.env[SERVICE_TOKEN_ENV_VAR];
+	const localWorkspaces = await new FileTokenStorage(context.runtime.env, context.runtime.signal).listWorkspaces();
+	if (rawServiceToken !== void 0) {
+		const authState = await readAuthState(context.runtime.env, context.runtime.signal);
+		return {
+			authSource: authState.authenticated ? "service_token" : "none",
+			activeWorkspace: authState.workspace,
+			workspaces: [...authState.workspace ? [{
+				...authState.workspace,
+				credentialWorkspaceId: null,
+				active: true,
+				source: "service_token",
+				switchable: false,
+				lastSeenAt: null
+			}] : [], ...localWorkspaces.map((workspace) => ({
+				...toAuthWorkspace(workspace),
+				credentialWorkspaceId: workspace.credentialWorkspaceId,
+				active: false,
+				source: "oauth",
+				switchable: false,
+				lastSeenAt: workspace.lastSeenAt
+			}))]
+		};
+	}
+	const active = localWorkspaces.find((workspace) => workspace.active) ?? null;
+	return {
+		authSource: localWorkspaces.length > 0 ? "oauth" : "none",
+		activeWorkspace: active ? toAuthWorkspace(active) : null,
+		workspaces: localWorkspaces.map((workspace) => ({
+			...toAuthWorkspace(workspace),
+			credentialWorkspaceId: workspace.credentialWorkspaceId,
+			active: workspace.active,
+			source: "oauth",
+			switchable: true,
+			lastSeenAt: workspace.lastSeenAt
+		}))
+	};
+}
+async function useRealAuthWorkspace(context, workspaceRef) {
+	if (context.runtime.env["PRISMA_SERVICE_TOKEN"] !== void 0) throw workspaceSwitchUnavailableError();
+	const storage = new FileTokenStorage(context.runtime.env, context.runtime.signal);
+	try {
+		const result = await storage.useWorkspace(workspaceRef);
+		return {
+			previousWorkspace: result.previous ? toAuthWorkspace(result.previous) : null,
+			workspace: toAuthWorkspace(result.selected)
+		};
+	} catch (error) {
+		if (error instanceof WorkspaceSelectionError) {
+			if (error.reason === "ambiguous") throw workspaceAmbiguousError(error.workspaceRef ?? workspaceRef, error.matches.map((match) => ({
+				id: match.id,
+				name: match.name,
+				credentialWorkspaceId: match.credentialWorkspaceId
+			})));
+			throw workspaceNotAuthenticatedError(error.workspaceRef ?? workspaceRef);
+		}
+		throw error;
+	}
+}
+async function logoutRealAuthWorkspace(context, workspaceRef) {
+	const storage = new FileTokenStorage(context.runtime.env, context.runtime.signal);
+	try {
+		const result = await storage.logoutWorkspace(workspaceRef);
+		return {
+			workspace: toAuthWorkspace(result.workspace),
+			wasActive: result.wasActive,
+			activeWorkspace: result.activeWorkspace ? toAuthWorkspace(result.activeWorkspace) : null
+		};
+	} catch (error) {
+		if (error instanceof WorkspaceSelectionError) {
+			if (error.reason === "ambiguous") throw workspaceAmbiguousError(error.workspaceRef ?? workspaceRef, error.matches.map((match) => ({
+				id: match.id,
+				name: match.name,
+				credentialWorkspaceId: match.credentialWorkspaceId
+			})));
+			throw workspaceNotAuthenticatedError(error.workspaceRef ?? workspaceRef);
+		}
+		throw error;
+	}
+}
+async function selectWorkspaceSession(context) {
+	const realMode = isRealMode(context);
+	if (realMode && context.runtime.env["PRISMA_SERVICE_TOKEN"] !== void 0) throw workspaceSwitchUnavailableError();
+	const workspaces = (realMode ? await listRealAuthWorkspaces(context) : await createAuthUseCases(createCliUseCaseGateways(context)).listWorkspaces()).workspaces.filter((workspace) => workspace.switchable);
+	if (workspaces.length === 0) throw usageError("No authenticated workspaces", "There are no local OAuth workspace sessions to select.", "Run prisma-cli auth login and authorize a workspace.", ["prisma-cli auth login"], "auth");
+	if (workspaces.length === 1) return workspaces[0].id;
+	if (!canPrompt(context)) throw usageError("Interactive workspace selection unavailable", "auth workspace select needs an interactive terminal when more than one workspace is available.", "Run prisma-cli auth workspace use <id-or-name> with a workspace from prisma-cli auth workspace list.", ["prisma-cli auth workspace list"], "auth");
+	return (await createSelectPromptPort(context).select({
+		message: "Select a workspace",
+		choices: workspaces.map((workspace) => ({
+			label: `${workspace.name} (${workspace.id})${workspace.active ? " active" : ""}`,
+			value: workspace
+		}))
+	})).id;
+}
+function toAuthWorkspace(workspace) {
+	return {
+		id: workspace.id,
+		name: workspace.name
+	};
+}
 async function loginWithSelectionFlow(context, useCases, options) {
 	const selection = await resolveLoginSelection(useCases, canPrompt(context) ? createSelectPromptPort(context) : null, options);
 	return useCases.login(selection);
@@ -104,4 +242,4 @@ function createAuthSuccess(command, result, nextSteps) {
 	};
 }
 //#endregion
-export { requireAuthenticatedAuthState, runAuthLogin, runAuthLogout, runAuthWhoAmI };
+export { requireAuthenticatedAuthState, runAuthLogin, runAuthLogout, runAuthWhoAmI, runAuthWorkspaceList, runAuthWorkspaceLogout, runAuthWorkspaceSelect, runAuthWorkspaceUse };

package/dist/controllers/project.js

@@ -1,11 +1,11 @@
 import { CliError, authRequiredError, featureUnavailableError, usageError, workspaceRequiredError } from "../shell/errors.js";
+import { createAppProvider } from "../lib/app/app-provider.js";
 import { renderSummaryLine } from "../shell/ui.js";
 import { canPrompt } from "../shell/runtime.js";
 import { readLocalResolutionPin } from "../lib/project/local-pin.js";
 import { formatCommandArgument } from "../shell/command-arguments.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 { createPreviewAppProvider } from "../lib/app/preview-provider.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
 import { promptForProjectSetupChoice } from "../lib/project/interactive-setup.js";
 import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
@@ -104,7 +104,7 @@ async function runProjectCreate(context, projectName) {
 	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, context.runtime.signal);
 	if (!client) throw authRequiredError();
-	const provider = createPreviewAppProvider(client);
+	const provider = createAppProvider(client);
 	const name = projectName.trim();
 	const created = await provider.createProject({
 		name,
@@ -136,7 +136,7 @@ async function runProjectLink(context, projectRef) {
 	if (isRealMode(context)) {
 		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 		if (!client) throw authRequiredError();
-		provider = createPreviewAppProvider(client);
+		provider = createAppProvider(client);
 		projects = await listRealWorkspaceProjects(client, workspace, context.runtime.signal);
 	} else projects = listFixtureWorkspaceProjects(context, workspace);
 	let result;

package/dist/lib/app/app-interaction.js

@@ -0,0 +1,5 @@
+import "../../shell/prompt.js";
+//#region src/lib/app/app-interaction.ts
+const DEFAULT_REGION = "eu-central-1";
+//#endregion
+export { DEFAULT_REGION };

package/dist/lib/app/{preview-provider.js → app-provider.js}

@@ -1,22 +1,22 @@
+import { createBranchDatabase, createEnvironmentVariable, deleteBranchDatabase, deleteEnvironmentVariable, listEnvironmentVariables, updateEnvironmentVariable } from "./branch-database-api.js";
+import { AppBuildStrategy } from "./build.js";
 import { envVarNames } from "./env-vars.js";
-import { PreviewBuildStrategy } from "./preview-build.js";
-import { createBranchDatabase, createEnvironmentVariable, deleteBranchDatabase, deleteEnvironmentVariable, listEnvironmentVariables, updateEnvironmentVariable } from "./preview-branch-database.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 {
+//#region src/lib/app/app-provider.ts
+var DomainApiError = class extends Error {
 	status;
 	code;
 	hint;
 	constructor(options) {
 		super(`${options.summary}: ${options.message}${options.hint ? ` ${options.hint}` : ""}`);
-		this.name = "PreviewDomainApiError";
+		this.name = "DomainApiError";
 		this.status = options.status;
 		this.code = options.code ?? null;
 		this.hint = options.hint ?? null;
 	}
 };
-function createPreviewAppProvider(client, options) {
+function createAppProvider(client, options) {
 	const sdk = new ComputeClient(client);
 	return {
 		async createProject(options) {
@@ -161,7 +161,7 @@ function createPreviewAppProvider(client, options) {
 				region: options.region
 			};
 			const deployResult = await sdk.deploy({
-				strategy: new PreviewBuildStrategy({
+				strategy: new AppBuildStrategy({
 					appPath: path.resolve(options.cwd),
 					entrypoint: options.entrypoint,
 					buildType: options.buildType,
@@ -491,7 +491,7 @@ function apiCallError(summary, response, error) {
 	return /* @__PURE__ */ new Error(`${summary}: ${message}${hint}`);
 }
 function domainApiCallError(summary, response, error) {
-	return new PreviewDomainApiError({
+	return new DomainApiError({
 		summary,
 		status: response.status,
 		code: error.error?.code ?? null,
@@ -541,4 +541,4 @@ function toAbsoluteUrl(url) {
 	return url.startsWith("https://") || url.startsWith("http://") ? url : `https://${url}`;
 }
 //#endregion
-export { PreviewDomainApiError, createPreviewAppProvider };
+export { DomainApiError, createAppProvider };

package/dist/lib/app/{preview-branch-database.js → branch-database-api.js}

@@ -1,4 +1,4 @@
-//#region src/lib/app/preview-branch-database.ts
+//#region src/lib/app/branch-database-api.ts
 async function createBranchDatabase(client, options) {
 	const result = await client.POST("/v1/databases", {
 		body: {

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

@@ -0,0 +1,93 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { resolveBuildSettings, resolveConfiguredBuildSettings } from "@prisma/compute-sdk";
+//#region src/lib/app/build-settings.ts
+/** Legacy build-settings file: no longer read or written, only detected for migration. */
+const PRISMA_APP_CONFIG_FILENAME = "prisma.app.json";
+/**
+* Detects a leftover `prisma.app.json`. The file is no longer used: one that
+* matches the effective settings is reported for deletion, one with custom
+* values must be migrated to the compute config so builds never silently
+* change.
+*/
+async function detectLegacyBuildSettings(options) {
+	const configPath = path.join(options.appPath, PRISMA_APP_CONFIG_FILENAME);
+	let content;
+	try {
+		options.signal?.throwIfAborted();
+		content = await readFile(configPath, {
+			encoding: "utf8",
+			signal: options.signal
+		});
+	} catch (error) {
+		if (options.signal?.aborted) throw error;
+		return { kind: "absent" };
+	}
+	let legacy;
+	try {
+		const parsed = JSON.parse(content);
+		const buildCommand = parsed.buildCommand === null || typeof parsed.buildCommand === "string" ? typeof parsed.buildCommand === "string" ? parsed.buildCommand.trim() || null : null : void 0;
+		const outputDirectory = typeof parsed.outputDirectory === "string" ? normalizeRelativePath(parsed.outputDirectory) : void 0;
+		if (buildCommand === void 0 || !outputDirectory) return {
+			kind: "invalid",
+			configPath
+		};
+		legacy = {
+			buildCommand,
+			outputDirectory
+		};
+	} catch {
+		return {
+			kind: "invalid",
+			configPath
+		};
+	}
+	return legacy.buildCommand === options.effective.buildCommand && legacy.outputDirectory === options.effective.outputDirectory ? {
+		kind: "matching",
+		configPath
+	} : {
+		kind: "custom",
+		configPath,
+		...legacy
+	};
+}
+/** Resolves build settings purely from framework inference; nothing is read or written. */
+async function resolveInferredAppBuildSettings(options) {
+	return {
+		status: "inferred",
+		configPath: null,
+		relativeConfigPath: null,
+		settings: await resolveBuildSettings(options)
+	};
+}
+/**
+* Resolves build settings when the compute config owns them: configured
+* fields win, omitted fields fall back to framework defaults.
+*/
+async function resolveConfiguredAppBuildSettings(options) {
+	const configFilename = path.basename(options.configPath);
+	const settings = await resolveConfiguredBuildSettings({
+		appPath: options.appPath,
+		buildType: options.buildType,
+		configured: options.configured,
+		source: `set by ${configFilename}`,
+		signal: options.signal
+	});
+	return {
+		status: "config",
+		configPath: options.configPath,
+		relativeConfigPath: configFilename,
+		settings
+	};
+}
+function normalizeRelativePath(value) {
+	const raw = value.trim().replace(/\\/g, "/");
+	if (raw.length === 0 || raw.split("/").includes("..")) return;
+	if (/^[A-Za-z]:/.test(raw)) return;
+	const normalized = path.posix.normalize(raw);
+	const segments = normalized.split("/");
+	if (path.win32.isAbsolute(value) || path.posix.isAbsolute(normalized) || segments.includes("..")) return;
+	return normalized === "." ? "." : normalized;
+}
+//#endregion
+export { PRISMA_APP_CONFIG_FILENAME, detectLegacyBuildSettings, resolveConfiguredAppBuildSettings, resolveInferredAppBuildSettings };

package/dist/lib/app/build.js

@@ -0,0 +1,80 @@
+import "./build-settings.js";
+import "node:fs/promises";
+import "node:path";
+import { normalizeArtifactSymlinks, resolveBuildStrategy } from "@prisma/compute-sdk";
+//#region src/lib/app/build.ts
+const APP_BUILD_TYPES = [
+	"auto",
+	"bun",
+	"nextjs",
+	"nuxt",
+	"astro",
+	"nestjs",
+	"tanstack-start"
+];
+const RESOLVED_APP_BUILD_TYPES = APP_BUILD_TYPES.filter((buildType) => buildType !== "auto");
+var AppBuildStrategy = class {
+	#appPath;
+	#entrypoint;
+	#buildType;
+	#signal;
+	#buildSettings;
+	constructor(options) {
+		this.#appPath = options.appPath;
+		this.#entrypoint = options.entrypoint;
+		this.#buildType = options.buildType ?? "auto";
+		this.#signal = options.signal;
+		this.#buildSettings = options.buildSettings;
+	}
+	async canBuild(signal = this.#signal) {
+		const { strategy } = await resolveAppBuildStrategy({
+			appPath: this.#appPath,
+			entrypoint: this.#entrypoint,
+			buildType: this.#buildType,
+			signal,
+			buildSettings: this.#buildSettings
+		});
+		return strategy.canBuild(signal);
+	}
+	async execute(signal = this.#signal) {
+		const { artifact } = await executeAppBuild({
+			appPath: this.#appPath,
+			entrypoint: this.#entrypoint,
+			buildType: this.#buildType,
+			signal,
+			buildSettings: this.#buildSettings
+		});
+		return artifact;
+	}
+};
+async function executeAppBuild(options) {
+	const { strategy, buildType } = await resolveAppBuildStrategy({
+		appPath: options.appPath,
+		entrypoint: options.entrypoint,
+		buildType: options.buildType ?? "auto",
+		signal: options.signal,
+		buildSettings: options.buildSettings
+	});
+	const artifact = await strategy.execute(options.signal);
+	try {
+		await normalizeArtifactSymlinks(artifact.directory, options.appPath, options.signal);
+		return {
+			artifact,
+			buildType
+		};
+	} catch (error) {
+		await artifact.cleanup?.().catch(() => void 0);
+		throw error;
+	}
+}
+async function resolveAppBuildStrategy(options) {
+	return resolveBuildStrategy({
+		appPath: options.appPath,
+		buildType: options.buildType,
+		entrypoint: options.entrypoint,
+		buildSettings: options.buildSettings,
+		signal: options.signal
+	});
+}
+//#endregion
+export { APP_BUILD_TYPES, AppBuildStrategy, RESOLVED_APP_BUILD_TYPES, executeAppBuild };