@prisma/cli 3.0.0-beta.16 → 3.0.0-beta.18

package/dist/controllers/app.js

@@ -1,16 +1,21 @@
+import { resolvePrismaCliPackageCommand } from "../lib/agent/cli-command.js";
+import { PRISMA_AGENT_INSTALL_ARGS, PRISMA_COMPUTE_AGENT_SKILL } from "../lib/agent/constants.js";
+import { readPrismaAgentSetupStatus, shouldOfferPrismaAgentSetup } from "../lib/agent/setup-status.js";
+import { formatCommandArgument } from "../shell/command-arguments.js";
+import { CliError, authRequiredError, featureUnavailableError, usageError, workspaceRequiredError } from "../shell/errors.js";
+import { runAgentInstall } from "./agent.js";
+import { renderCommandHeader, renderSummaryLine } from "../shell/ui.js";
+import { canPrompt } from "../shell/runtime.js";
+import { writeJsonEvent } from "../shell/output.js";
 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 "../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 { APP_BUILD_TYPES, APP_BUILD_TYPE_LABELS, 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, 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";
@@ -27,19 +32,19 @@ import { requireComputeAuth } from "../lib/auth/guard.js";
 import { readAuthState } from "../lib/auth/auth-ops.js";
 import { readLocalGitBranch } from "../lib/git/local-branch.js";
 import { promptForProjectSetupChoice } from "../lib/project/interactive-setup.js";
-import { writeJsonEvent } from "../shell/output.js";
 import { createSelectPromptPort } from "./select-prompt-port.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
 import { listRealWorkspaceProjects } from "./project.js";
-import { ENTRYPOINT_BUILD_TYPES, FRAMEWORKS, LOCAL_DEV_BUILD_TYPES, frameworkByKey, frameworkFromAlias, isConfigBackedBuildType } from "@prisma/compute-sdk/config";
-import { access, readFile } from "node:fs/promises";
 import path from "node:path";
+import { access, readFile } from "node:fs/promises";
+import { COMPUTE_REGIONS, ENTRYPOINT_BUILD_TYPES, FRAMEWORKS, LOCAL_DEV_BUILD_TYPES, frameworkByKey, frameworkFromAlias, isConfigBackedBuildType } from "@prisma/compute-sdk/config";
 import { Result, matchError } from "better-result";
 import open from "open";
 //#region src/controllers/app.ts
 const FRAMEWORK_DEFAULT_HTTP_PORT = 3e3;
 const PRISMA_PROJECT_ID_ENV_VAR = "PRISMA_PROJECT_ID";
 const PRISMA_APP_ID_ENV_VAR = "PRISMA_APP_ID";
+const COMPUTE_REGION_IDS = new Set(COMPUTE_REGIONS);
 function isRealMode(context) {
 	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
 }
@@ -154,7 +159,7 @@ async function runAppDeploy(context, appName, options) {
 	return runSingleAppDeploy(context, appName, options, config);
 }
 async function runAppDeployAll(context, config, plannedTargets, appName, options) {
-	assertNoPerAppInputsForDeployAll(context, config, appName, options);
+	assertNoPerAppInputsForDeployAll(context, plannedTargets, appName, options);
 	const deployments = [];
 	const warnings = [];
 	for (const planned of plannedTargets) {
@@ -172,7 +177,7 @@ async function runAppDeployAll(context, config, plannedTargets, appName, options
 			});
 			warnings.push(...single.warnings);
 		} catch (error) {
-			throw deployAllFailedError(error, config, planned.index, deployments);
+			throw deployAllFailedError(error, plannedTargets, planned.index, deployments);
 		}
 	}
 	return {
@@ -182,12 +187,13 @@ async function runAppDeployAll(context, config, plannedTargets, appName, options
 		nextSteps: ["prisma-cli app list-deploys <app>"]
 	};
 }
-function assertNoPerAppInputsForDeployAll(context, config, appName, options) {
+function assertNoPerAppInputsForDeployAll(context, plannedTargets, appName, options) {
 	const used = perAppInputsForDeployAll({
 		appName,
 		framework: options?.framework,
 		entrypoint: options?.entrypoint,
 		httpPort: options?.httpPort,
+		region: options?.region,
 		envAssignments: options?.envAssignments,
 		appIdEnvVar: {
 			name: PRISMA_APP_ID_ENV_VAR,
@@ -195,17 +201,17 @@ function assertNoPerAppInputsForDeployAll(context, config, appName, options) {
 		}
 	});
 	if (used.length === 0) return;
-	const targets = config.targets.map((target) => target.key).join(", ");
-	throw usageError(`Deploying all apps does not accept ${used.join(", ")}`, `Without a target, app deploy deploys every configured app (${targets}), so per-app inputs are ambiguous.`, "Pass the app target to apply per-app inputs to one app, or remove them to deploy all apps.", config.targets.map((target) => `prisma-cli app deploy ${target.key}`), "app");
+	const targetKeys = plannedTargets.map((target) => target.targetKey);
+	throw usageError(`Deploying all apps does not accept ${used.join(", ")}`, `Without a target, app deploy deploys every configured app (${targetKeys.join(", ")}), so per-app inputs are ambiguous.`, "Pass the app target to apply per-app inputs to one app, or remove them to deploy all apps.", targetKeys.map((target) => `prisma-cli app deploy ${target}`), "app");
 }
 function maybeRenderDeployAllTargetHeader(context, planned) {
 	if (context.flags.json || context.flags.quiet) return;
 	context.output.stderr.write(`${planned.index > 0 ? "\n" : ""}── ${planned.targetKey} (${planned.index + 1}/${planned.total}) ──\n\n`);
 }
-function deployAllFailedError(error, config, failedIndex, deployments) {
+function deployAllFailedError(error, plannedTargets, failedIndex, deployments) {
 	if (!(error instanceof CliError)) return error;
 	const failure = describeDeployAllFailure({
-		targetKeys: config.targets.map((target) => target.key),
+		targetKeys: plannedTargets.map((target) => target.targetKey),
 		failedIndex,
 		completed: deployments.map(({ target, result }) => ({
 			target,
@@ -255,6 +261,7 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 			framework: options?.framework,
 			entrypoint: options?.entrypoint,
 			httpPort: options?.httpPort,
+			region: options?.region,
 			envInputs: options?.envAssignments
 		},
 		target: computeConfig.target,
@@ -262,11 +269,13 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 	});
 	const appDir = await resolveComputeAppDir(context, computeConfig);
 	const projectDir = computeConfig.config?.configDir ?? context.runtime.cwd;
+	const agentSetupWarnings = await maybePromptForAgentSetup(context, projectDir);
 	const localPinReadResult = Boolean(envProjectId || options?.projectRef || options?.createProjectName) ? Result.ok({ kind: "missing" }) : await readLocalResolutionPin(projectDir, context.runtime.signal);
 	if (localPinReadResult.isErr()) throw localPinReadErrorToDeployError(localPinReadResult.error);
 	const localPin = localPinReadResult.value;
 	const branch = await resolveDeployBranch(context, options?.branchName);
 	if (merged.httpPort) parseDeployHttpPort(merged.httpPort.value);
+	const deployRegion = normalizeDeployRegionInput(merged.region);
 	assertSupportedEntrypointForRequestedDeployShape({
 		requestedFramework: merged.framework?.value,
 		entrypoint: merged.entrypoint?.value
@@ -299,6 +308,7 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 		explicitAppName: appName,
 		explicitAppId: envAppId,
 		configAppName: merged.configAppName,
+		configRegion: deployRegion,
 		firstDeploy: Boolean(target.localPinAction),
 		inferName: () => inferTargetName(appDir, context.runtime.signal)
 	});
@@ -328,15 +338,9 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 	const buildType = framework.buildType;
 	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 resolveConfiguredAppBuildSettings({
-		appPath: appDir,
-		buildType,
-		configured: computeConfig.target.build,
-		configPath: computeConfig.config.configPath,
-		signal: context.runtime.signal
-	}) : await resolveInferredAppBuildSettings({
-		appPath: appDir,
+	const buildSettingsResolution = await resolveDeployBuildSettings({
+		computeConfig,
+		appDir,
 		buildType,
 		signal: context.runtime.signal
 	});
@@ -407,18 +411,38 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 					name: framework.displayName,
 					source: framework.annotation
 				},
-				entrypoint: entrypoint ?? null,
+				entrypoint: entrypoint ?? buildSettingsResolution.settings.entrypoint ?? null,
 				httpPort: runtime.port,
-				region: selectedApp.region ?? null,
+				region: deployResult.app.region ?? selectedApp.region ?? null,
 				envVars: envVarNames(envVars)
 			},
 			durationMs: deployDurationMs,
 			localPin: localPinResult
 		},
-		warnings: [...legacyWarnings, ...branchDatabaseSetup.warnings],
+		warnings: [
+			...agentSetupWarnings,
+			...legacyWarnings,
+			...branchDatabaseSetup.warnings
+		],
 		nextSteps: ["prisma-cli app list-deploys", `prisma-cli app show-deploy ${deployResult.deployment.id}`]
 	};
 }
+async function resolveDeployBuildSettings(options) {
+	const { computeConfig, appDir, buildType, signal } = options;
+	if (computeConfig.target?.build) assertConfigBackedBuildSettings(buildType);
+	if (computeConfig.config && computeConfig.target?.build && isConfigBackedBuildType(buildType)) return resolveConfiguredAppBuildSettings({
+		appPath: appDir,
+		buildType,
+		configured: computeConfig.target.build,
+		configPath: computeConfig.config.configPath,
+		signal
+	});
+	return resolveInferredAppBuildSettings({
+		appPath: appDir,
+		buildType,
+		signal
+	});
+}
 async function runAppListDeploys(context, appName, projectRef, configTarget) {
 	ensurePreviewAppMode(context);
 	const compute = await resolveComputeManagementContext(context, configTarget, "list-deploys");
@@ -1102,6 +1126,7 @@ async function confirmDomainRemoval(context, target, hostname) {
 	if (!await confirmPrompt({
 		input: context.runtime.stdin,
 		output: context.output.stderr,
+		signal: context.runtime.signal,
 		message: `Detach ${hostname} from App "${target.app.name}"?`,
 		initialValue: false
 	})) 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");
@@ -1276,27 +1301,19 @@ async function sleep(milliseconds, signal) {
 	});
 }
 async function resolveDeployAppSelection(context, projectId, apps, options) {
-	if (options.explicitAppName) {
-		const matches = findAppsByName(apps, options.explicitAppName);
-		if (matches.length > 1) return resolveAmbiguousDeployApp(context, matches, options.explicitAppName, options.firstDeploy);
-		const matched = matches[0];
-		if (matched) return {
-			appId: matched.id,
-			displayName: matched.name,
-			annotation: "set by --app",
-			firstDeploy: options.firstDeploy
-		};
-		return {
-			appName: options.explicitAppName,
-			region: DEFAULT_REGION,
-			displayName: options.explicitAppName,
-			annotation: "set by --app",
-			firstDeploy: options.firstDeploy
-		};
-	}
+	const newAppRegion = deployNewAppRegion(options.configRegion);
+	if (options.explicitAppName) return resolveDeployAppByName(context, apps, {
+		name: options.explicitAppName,
+		matchedAnnotation: "set by --app",
+		newAnnotation: "set by --app",
+		requestedRegion: options.configRegion,
+		newAppRegion,
+		firstDeploy: options.firstDeploy
+	});
 	if (options.explicitAppId) {
 		const matched = apps.find((app) => app.id === options.explicitAppId);
 		if (!matched) throw usageError("Selected app does not exist in the resolved project", `The app "${options.explicitAppId}" from ${PRISMA_APP_ID_ENV_VAR} could not be found in resolved project "${projectId}".`, `Unset ${PRISMA_APP_ID_ENV_VAR}, pass --app <name>, or choose an app from prisma-cli app list-deploys.`, ["prisma-cli app list-deploys"], "app");
+		assertDeployRegionMatchesExistingApp(matched, options.configRegion);
 		return {
 			appId: matched.id,
 			displayName: matched.name,
@@ -1306,42 +1323,52 @@ async function resolveDeployAppSelection(context, projectId, apps, options) {
 	}
 	if (options.configAppName) {
 		const configName = options.configAppName;
-		const matches = findAppsByName(apps, configName.value);
-		if (matches.length > 1) return resolveAmbiguousDeployApp(context, matches, configName.value, options.firstDeploy);
-		const matched = matches[0];
-		if (matched) return {
-			appId: matched.id,
-			displayName: matched.name,
-			annotation: configName.annotation,
+		return resolveDeployAppByName(context, apps, {
+			name: configName.value,
+			matchedAnnotation: configName.annotation,
+			newAnnotation: configName.annotation,
+			requestedRegion: options.configRegion,
+			newAppRegion,
 			firstDeploy: options.firstDeploy
-		};
+		});
+	}
+	const inferredName = await options.inferName();
+	const newAnnotation = inferredName.source === "package-name" ? "created from package.json" : "created from directory name";
+	return resolveDeployAppByName(context, apps, {
+		name: inferredName.name,
+		matchedAnnotation: "existing app on this branch",
+		newAnnotation,
+		requestedRegion: options.configRegion,
+		newAppRegion,
+		firstDeploy: options.firstDeploy
+	});
+}
+async function resolveDeployAppByName(context, apps, options) {
+	const matches = findAppsByName(apps, options.name);
+	if (matches.length > 1) return resolveAmbiguousDeployApp(context, matches, options.name, options.requestedRegion, options.newAppRegion, options.firstDeploy);
+	const matched = matches[0];
+	if (matched) {
+		assertDeployRegionMatchesExistingApp(matched, options.requestedRegion);
 		return {
-			appName: configName.value,
-			region: DEFAULT_REGION,
-			displayName: configName.value,
-			annotation: configName.annotation,
+			appId: matched.id,
+			displayName: matched.name,
+			annotation: options.matchedAnnotation,
 			firstDeploy: options.firstDeploy
 		};
 	}
-	const inferredName = await options.inferName();
-	const matches = findAppsByName(apps, inferredName.name);
-	if (matches.length > 1) return resolveAmbiguousDeployApp(context, matches, inferredName.name, options.firstDeploy);
-	const matched = matches[0];
-	if (matched) return {
-		appId: matched.id,
-		displayName: matched.name,
-		annotation: "existing app on this branch",
-		firstDeploy: options.firstDeploy
-	};
 	return {
-		appName: inferredName.name,
-		region: DEFAULT_REGION,
-		displayName: inferredName.name,
-		annotation: inferredName.source === "package-name" ? "created from package.json" : "created from directory name",
+		appName: options.name,
+		region: options.newAppRegion,
+		displayName: options.name,
+		annotation: options.newAnnotation,
 		firstDeploy: options.firstDeploy
 	};
 }
-async function resolveAmbiguousDeployApp(context, matches, targetName, firstDeploy) {
+function assertDeployRegionMatchesExistingApp(app, requestedRegion) {
+	if (requestedRegion?.annotation !== "set by --region" || !app.region || app.region === requestedRegion.value) return;
+	throw usageError("App already exists in another region", `The selected app "${app.name}" is in region "${app.region}", but --region requested "${requestedRegion.value}".`, "Remove --region to deploy the existing app, or pass --app <new-name> to create a new app in that region.", [`prisma-cli app deploy --app ${formatCommandArgument(app.name)}`, `prisma-cli app deploy --app <new-name> --region ${formatCommandArgument(requestedRegion.value)}`], "app");
+}
+async function resolveAmbiguousDeployApp(context, matches, targetName, requestedRegion, newAppRegion, firstDeploy) {
 	if (canPrompt(context)) {
 		const createNew = "__create_new_app__";
 		const cancel = "__cancel__";
@@ -1367,11 +1394,12 @@ 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: DEFAULT_REGION,
+			region: newAppRegion,
 			displayName: targetName,
 			annotation: "created from package.json",
 			firstDeploy
 		};
+		assertDeployRegionMatchesExistingApp(selected, requestedRegion);
 		return {
 			appId: selected.id,
 			displayName: selected.name,
@@ -1393,6 +1421,9 @@ async function resolveAmbiguousDeployApp(context, matches, targetName, firstDepl
 		nextSteps: ["prisma-cli app deploy --app <name>"]
 	});
 }
+function deployNewAppRegion(configRegion) {
+	return configRegion?.value ?? "eu-central-1";
+}
 async function resolveExistingAppSelection(context, projectId, apps, explicitAppName) {
 	if (explicitAppName) {
 		const matched = findAppByName(apps, explicitAppName);
@@ -1435,6 +1466,7 @@ async function confirmAppRemoval(context, app) {
 	await textPrompt({
 		input: context.runtime.stdin,
 		output: context.output.stderr,
+		signal: context.runtime.signal,
 		message: `Type ${app.name} to confirm app removal`,
 		placeholder: app.name,
 		validate: (value) => value === app.name ? void 0 : `Type "${app.name}" to confirm removal.`
@@ -1996,11 +2028,6 @@ function frameworkFromUserFacingValue(value, annotation) {
 		annotation
 	};
 }
-/**
-* The nuxt and astro strategies build with their framework CLI and stage
-* fixed output, so a compute config `build` block has nothing to apply to.
-* Erroring beats silently ignoring committed settings.
-*/
 function assertConfigBackedBuildSettings(buildType) {
 	if (isConfigBackedBuildType(buildType)) return;
 	const displayName = FRAMEWORKS.find((framework) => framework.buildType === buildType)?.displayName ?? buildType;
@@ -2042,20 +2069,64 @@ function maybeRenderDeployBuildSettings(context, resolution) {
 	if (context.flags.json || context.flags.quiet) return;
 	const settings = resolution.settings;
 	const title = resolution.status === "config" ? `Using ${resolution.relativeConfigPath}` : "Build settings";
-	context.output.stderr.write(`${title}\n${renderDeployOutputRows(context.ui, [{
-		label: "Build Command",
-		value: settings.buildCommand ?? "none",
-		origin: settings.buildCommandSource ?? void 0
-	}, {
-		label: "Output Directory",
-		value: settings.outputDirectory,
-		origin: settings.outputDirectorySource ?? void 0
-	}]).join("\n")}\n\n`);
+	context.output.stderr.write(`${title}\n${renderDeployOutputRows(context.ui, [
+		{
+			label: "Build Command",
+			value: settings.buildCommand ?? "none",
+			origin: settings.buildCommandSource ?? void 0
+		},
+		{
+			label: "Output Directory",
+			value: settings.outputDirectory,
+			origin: settings.outputDirectorySource ?? void 0
+		},
+		...settings.entrypoint ? [{
+			label: "Entrypoint",
+			value: settings.entrypoint,
+			origin: settings.entrypointSource ?? void 0
+		}] : []
+	]).join("\n")}\n\n`);
 }
 function maybeRenderProjectLinked(context, directory, projectName, localPinPath) {
 	if (context.flags.json || context.flags.quiet) return;
 	context.output.stderr.write(`${context.ui.success("✔")} Linked "${directory}" to Project "${projectName}"\nSaved ${localPinPath}\n\n`);
 }
+async function maybePromptForAgentSetup(context, projectDir) {
+	if (!canPrompt(context) || context.flags.yes) return [];
+	if (!shouldOfferPrismaAgentSetup(await readPrismaAgentSetupStatus({
+		cwd: projectDir,
+		stateStore: context.stateStore,
+		signal: context.runtime.signal,
+		requiredSkill: "prisma-compute"
+	}))) return [];
+	if (!await confirmPrompt({
+		input: context.runtime.stdin,
+		output: context.runtime.stderr,
+		signal: context.runtime.signal,
+		message: "Install the Prisma Compute skill for this project?",
+		initialValue: true
+	})) {
+		await context.stateStore.setAgentSetupPromptDismissedAt((/* @__PURE__ */ new Date()).toISOString());
+		return [];
+	}
+	try {
+		await runAgentInstall(context, { skill: [PRISMA_COMPUTE_AGENT_SKILL] }, "install", { cwd: projectDir });
+		if (!context.flags.quiet && !context.flags.json) context.output.stderr.write(`${renderSummaryLine(context.ui, "success", "Installed the Prisma Compute skill for this project.")}\n\n`);
+		return [];
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Prisma skill install failed.";
+		if (!context.flags.quiet && !context.flags.json) context.output.stderr.write(`${renderSummaryLine(context.ui, "warning", `Skipped Prisma skill install: ${message}`)}\n\n`);
+		return [`The Prisma Compute skill was not installed. Run ${await resolvePrismaCliPackageCommand({
+			cwd: projectDir,
+			signal: context.runtime.signal,
+			args: [
+				...PRISMA_AGENT_INSTALL_ARGS,
+				"--skill",
+				PRISMA_COMPUTE_AGENT_SKILL
+			]
+		})} to try again.`];
+	}
+}
 async function maybeCustomizeDeploySettings(context, options) {
 	if (!options.firstDeploy || context.flags.yes || options.explicitFramework || options.explicitEntrypoint || options.explicitHttpPort || !canPrompt(context)) return {
 		framework: options.framework,
@@ -2068,6 +2139,7 @@ async function maybeCustomizeDeploySettings(context, options) {
 	if (!await confirmPrompt({
 		input: context.runtime.stdin,
 		output: context.runtime.stderr,
+		signal: context.runtime.signal,
 		message: "Customize build settings?",
 		initialValue: false
 	})) return {
@@ -2077,6 +2149,7 @@ async function maybeCustomizeDeploySettings(context, options) {
 	const framework = frameworkFromUserFacingValue(await selectPrompt({
 		input: context.runtime.stdin,
 		output: context.runtime.stderr,
+		signal: context.runtime.signal,
 		message: `Framework (${options.framework.displayName})`,
 		choices: FRAMEWORKS.map((framework) => ({
 			label: framework.displayName,
@@ -2086,6 +2159,7 @@ async function maybeCustomizeDeploySettings(context, options) {
 	const requestedPort = await textPrompt({
 		input: context.runtime.stdin,
 		output: context.runtime.stderr,
+		signal: context.runtime.signal,
 		message: `HTTP port (${options.runtime.port})`,
 		placeholder: String(options.runtime.port),
 		validate: validateDeployHttpPortText
@@ -2149,7 +2223,7 @@ async function readCurrentWorkspaceId(context) {
 function normalizeBuildType(requestedBuildType) {
 	if (!requestedBuildType) return "auto";
 	if (isPreviewBuildType(requestedBuildType)) return requestedBuildType;
-	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");
+	throw usageError(`Unsupported build type "${requestedBuildType}"`, `Only ${APP_BUILD_TYPE_LABELS} are supported in the current preview.`, "Pass a supported --build-type value.", getBuildTypeExamples("build"), "app");
 }
 function isPreviewBuildType(value) {
 	return APP_BUILD_TYPES.includes(value);
@@ -2195,6 +2269,19 @@ function parseDeployHttpPort(requestedPort) {
 	if (!Number.isInteger(port) || port <= 0 || port > 65535) throw usageError(`Invalid HTTP port "${requestedPort}"`, "HTTP port must be an integer between 1 and 65535.", "Pass --http-port <number> with a valid port value.", ["prisma-cli app deploy --http-port 3000"], "app");
 	return port;
 }
+function parseDeployRegion(requestedRegion, source) {
+	const region = requestedRegion.trim();
+	if (region.length === 0) throw usageError("Invalid app region", `The app region ${source} must be a non-empty region id.`, "Pass a Prisma Compute region id.", ["prisma-cli app deploy --region eu-central-1"], "app");
+	if (!COMPUTE_REGION_IDS.has(region)) throw usageError("Invalid app region", `The app region ${source} must be one of: ${COMPUTE_REGIONS.join(", ")}.`, "Pass a supported Prisma Compute region id.", ["prisma-cli app deploy --region eu-central-1"], "app");
+	return region;
+}
+function normalizeDeployRegionInput(region) {
+	if (!region) return;
+	return {
+		...region,
+		value: parseDeployRegion(region.value, region.annotation)
+	};
+}
 function ensurePreviewAppMode(context) {
 	if (isRealMode(context)) return;
 	throw featureUnavailableError("App commands are not available in fixture mode", "Preview app commands require live app deployment integration.", "Rerun without fixture mode enabled to use preview app deployment workflows.", ["prisma-cli auth login", "prisma-cli project show"], "app");
@@ -2251,7 +2338,7 @@ function appDeployFailedError(error, progress) {
 	}
 	if (!progress.buildStarted) return deployFailedError("App deploy failed", error, ["prisma-cli app deploy"]);
 	const phaseHeadline = progress.containerLive ? "The deployment started, but the app is not ready yet." : "Deploy failed after the build completed.";
-	const recoveryLines = progress.versionId ? ["See what happened", `prisma-cli app logs --deployment ${progress.versionId}`] : ["Fix", "Retry the command, or rerun with --trace for more detailed diagnostics."];
+	const recoveryLines = progress.deploymentId ? ["See what happened", `prisma-cli app logs --deployment ${progress.deploymentId}`] : ["Fix", "Retry the command, or rerun with --trace for more detailed diagnostics."];
 	const urlLines = progress.deploymentUrl ? [
 		"",
 		"URL",
@@ -2277,11 +2364,11 @@ function appDeployFailedError(error, progress) {
 		domain: "app",
 		summary: phaseHeadline,
 		why,
-		fix: progress.versionId ? `Inspect logs with prisma-cli app logs --deployment ${progress.versionId}.` : "Retry the command, or rerun with --trace for more detailed diagnostics.",
+		fix: progress.deploymentId ? `Inspect logs with prisma-cli app logs --deployment ${progress.deploymentId}.` : "Retry the command, or rerun with --trace for more detailed diagnostics.",
 		debug,
 		meta: {
 			phase: progress.containerLive ? "runtime_ready" : "deploy",
-			deploymentId: progress.versionId,
+			deploymentId: progress.deploymentId,
 			deploymentUrl: progress.deploymentUrl
 		},
 		humanLines,
@@ -2395,15 +2482,12 @@ function isAutoBuildDetectionError(error) {
 	return error instanceof Error && error.message.startsWith("Entrypoint is required.");
 }
 function formatBuildTypeName(buildType) {
-	switch (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";
+	if (buildType === "auto") return "Auto";
+	for (let index = FRAMEWORKS.length - 1; index >= 0; index -= 1) {
+		const framework = FRAMEWORKS[index];
+		if (framework?.buildType === buildType) return framework.displayName;
 	}
+	return buildType;
 }
 function removeFailedError(summary, error, nextSteps) {
 	return new CliError({

package/dist/controllers/auth.js

@@ -1,7 +1,10 @@
-import { CLIENT_ID, SERVICE_TOKEN_ENV_VAR, getApiBaseUrl } from "../lib/auth/client.js";
-import { FileTokenStorage, WorkspaceSelectionError } from "../adapters/token-storage.js";
+import { resolvePrismaCliPackageCommand } from "../lib/agent/cli-command.js";
+import { PRISMA_AGENT_INSTALL_ARGS } from "../lib/agent/constants.js";
+import { isLikelyProjectDirectory, readPrismaAgentSetupStatus, resolvePrismaAgentSetupCwd, shouldOfferPrismaAgentSetup } from "../lib/agent/setup-status.js";
 import { authRequiredError, usageError, workspaceAmbiguousError, workspaceNotAuthenticatedError, workspaceSwitchUnavailableError } from "../shell/errors.js";
 import { canPrompt } from "../shell/runtime.js";
+import { CLIENT_ID, SERVICE_TOKEN_ENV_VAR, getApiBaseUrl } from "../lib/auth/client.js";
+import { FileTokenStorage, WorkspaceSelectionError } from "../adapters/token-storage.js";
 import { performLogin, performLogout, readAuthState } from "../lib/auth/auth-ops.js";
 import { createAuthUseCases } from "../use-cases/auth.js";
 import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
@@ -17,7 +20,16 @@ async function runAuthLogin(context, options) {
 		await performLogin(context.runtime.env, context.runtime.signal);
 		result = await readAuthState(context.runtime.env, context.runtime.signal);
 	} else result = await loginWithSelectionFlow(context, createAuthUseCases(createCliUseCaseGateways(context)), options);
-	return createAuthSuccess("auth.login", result, ["prisma-cli auth whoami", "prisma-cli project list"]);
+	const agentSetupTipCommand = await resolveAgentSetupTipCommand(context);
+	if (agentSetupTipCommand) result = {
+		...result,
+		agentSetupTip: { command: agentSetupTipCommand }
+	};
+	return createAuthSuccess("auth.login", result, [
+		"prisma-cli auth whoami",
+		"prisma-cli project list",
+		...result.agentSetupTip ? [result.agentSetupTip.command] : []
+	]);
 }
 async function runAuthLogout(context) {
 	let result;
@@ -312,5 +324,28 @@ function createAuthSuccess(command, result, nextSteps) {
 		nextSteps
 	};
 }
+async function resolveAgentSetupTipCommand(context) {
+	if (context.flags.json || context.flags.quiet) return null;
+	if (context.runtime.env.CI && context.flags.interactive !== true) return null;
+	if (!context.runtime.stderr.isTTY && context.flags.interactive !== true) return null;
+	const setupCwd = await resolvePrismaAgentSetupCwd({
+		cwd: context.runtime.cwd,
+		signal: context.runtime.signal
+	});
+	if (!await isLikelyProjectDirectory({
+		cwd: setupCwd,
+		signal: context.runtime.signal
+	})) return null;
+	if (!shouldOfferPrismaAgentSetup(await readPrismaAgentSetupStatus({
+		cwd: setupCwd,
+		stateStore: context.stateStore,
+		signal: context.runtime.signal
+	}))) return null;
+	return await resolvePrismaCliPackageCommand({
+		cwd: setupCwd,
+		signal: context.runtime.signal,
+		args: PRISMA_AGENT_INSTALL_ARGS
+	});
+}
 //#endregion
 export { requireAuthenticatedAuthState, runAuthLogin, runAuthLogout, runAuthWhoAmI, runAuthWorkspaceList, runAuthWorkspaceLogout, runAuthWorkspaceUse };

package/dist/controllers/project.js

@@ -1,9 +1,9 @@
+import { formatCommandArgument } from "../shell/command-arguments.js";
 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 { createAppProvider } from "../lib/app/app-provider.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 { requireComputeAuth } from "../lib/auth/guard.js";

package/dist/controllers/select-prompt-port.js

@@ -4,6 +4,7 @@ function createSelectPromptPort(context) {
 	return { select: ({ message, choices }) => selectPrompt({
 		input: context.runtime.stdin,
 		output: context.runtime.stderr,
+		signal: context.runtime.signal,
 		message,
 		choices
 	}) };

package/dist/lib/agent/cli-command.js

@@ -0,0 +1,17 @@
+import { formatPrismaCliCommand } from "../../shell/cli-command.js";
+import { resolvePackageRunner, resolvePackageRunnerSync } from "./package-manager.js";
+//#region src/lib/agent/cli-command.ts
+async function resolvePrismaCliPackageCommandFormatter(options) {
+	return createPrismaCliPackageCommandFormatter(await resolvePackageRunner(options));
+}
+async function resolvePrismaCliPackageCommand(options) {
+	return (await resolvePrismaCliPackageCommandFormatter(options))(options.args);
+}
+function resolvePrismaCliPackageCommandFormatterSync(cwd) {
+	return createPrismaCliPackageCommandFormatter(resolvePackageRunnerSync(cwd));
+}
+function createPrismaCliPackageCommandFormatter(packageRunner) {
+	return (args) => formatPrismaCliCommand(args, { packageRunner });
+}
+//#endregion
+export { resolvePrismaCliPackageCommand, resolvePrismaCliPackageCommandFormatterSync };

package/dist/lib/agent/constants.js

@@ -0,0 +1,12 @@
+//#region src/lib/agent/constants.ts
+const PRISMA_SKILLS_SOURCE = "prisma/skills";
+const PRISMA_SKILLS_LOCK_FILENAME = "skills-lock.json";
+const SKILLS_CLI_PACKAGE = "skills@latest";
+const DEFAULT_PRISMA_AGENT_SKILLS = ["*"];
+const PRISMA_COMPUTE_AGENT_SKILL = "prisma-compute";
+const DEFAULT_PRISMA_AGENT_TARGETS = ["codex", "claude-code"];
+const PRISMA_AGENT_INSTALL_ARGS = ["agent", "install"];
+const PRISMA_AGENT_UPDATE_ARGS = ["agent", "update"];
+const PRISMA_AGENT_STATUS_ARGS = ["agent", "status"];
+//#endregion
+export { DEFAULT_PRISMA_AGENT_SKILLS, DEFAULT_PRISMA_AGENT_TARGETS, PRISMA_AGENT_INSTALL_ARGS, PRISMA_AGENT_STATUS_ARGS, PRISMA_AGENT_UPDATE_ARGS, PRISMA_COMPUTE_AGENT_SKILL, PRISMA_SKILLS_LOCK_FILENAME, PRISMA_SKILLS_SOURCE, SKILLS_CLI_PACKAGE };