@prisma/cli 3.0.0-dev.86.1 → 3.0.0-dev.88.1

package/dist/lib/app/local-dev.js

@@ -1,25 +1,9 @@
-import { readBunPackageEntrypoint, readBunPackageJson, resolveBunEntrypoint } from "./bun-project.js";
-import { access } from "node:fs/promises";
+import { resolveBunEntrypoint } from "./bun-project.js";
+import "node:fs/promises";
 import path from "node:path";
 import { spawn } from "node:child_process";
 //#region src/lib/app/local-dev.ts
-const NEXT_CONFIG_FILENAMES = [
-	"next.config.js",
-	"next.config.mjs",
-	"next.config.ts",
-	"next.config.mts"
-];
 const DEFAULT_LOCAL_DEV_PORT = 3e3;
-async function resolveLocalBuildType(appPath, buildType, signal) {
-	if (buildType === "bun" || buildType === "nextjs") return buildType;
-	if (buildType !== "auto") return null;
-	return detectLocalBuildType(appPath, signal);
-}
-async function detectLocalBuildType(appPath, signal) {
-	if (await isNextProject(appPath, signal)) return "nextjs";
-	if (await isBunProject(appPath, signal)) return "bun";
-	return null;
-}
 async function runLocalApp(options) {
 	const spawnImpl = options.spawnImpl ?? spawn;
 	if (options.buildType === "nextjs") {
@@ -92,47 +76,6 @@ async function runLocalApp(options) {
 		signal: command.signal
 	};
 }
-async function isNextProject(appPath, signal) {
-	for (const fileName of NEXT_CONFIG_FILENAMES) {
-		signal?.throwIfAborted();
-		try {
-			await access(path.join(appPath, fileName));
-			signal?.throwIfAborted();
-			return true;
-		} catch (error) {
-			if (signal?.aborted) throw error;
-		}
-	}
-	return hasDependency(await readBunPackageJson(appPath, signal), "next");
-}
-async function isBunProject(appPath, signal) {
-	signal?.throwIfAborted();
-	try {
-		await access(path.join(appPath, "bun.lock"));
-		signal?.throwIfAborted();
-		return true;
-	} catch (error) {
-		if (signal?.aborted) throw error;
-	}
-	signal?.throwIfAborted();
-	try {
-		await access(path.join(appPath, "bun.lockb"));
-		signal?.throwIfAborted();
-		return true;
-	} catch (error) {
-		if (signal?.aborted) throw error;
-	}
-	const packageJson = await readBunPackageJson(appPath, signal);
-	if (!packageJson) return false;
-	const hasEntrypoint = typeof readBunPackageEntrypoint(packageJson) === "string";
-	const hasBunDependency = hasDependency(packageJson, "@types/bun") || hasDependency(packageJson, "bun");
-	const usesBunScripts = (typeof packageJson.scripts === "object" && packageJson.scripts !== null ? Object.values(packageJson.scripts) : []).some((value) => typeof value === "string" && /\bbun\b/.test(value));
-	return hasEntrypoint && (hasBunDependency || usesBunScripts);
-}
-function hasDependency(packageJson, dependencyName) {
-	if (!packageJson) return false;
-	return [packageJson.dependencies, packageJson.devDependencies].some((group) => typeof group === "object" && group !== null && dependencyName in group);
-}
 async function runWithFallback(candidates, options, spawnImpl, missingCommandMessage) {
 	for (const candidate of candidates) try {
 		const result = await spawnCommand(candidate, options, spawnImpl);
@@ -163,4 +106,4 @@ function spawnCommand(candidate, options, spawnImpl) {
 	});
 }
 //#endregion
-export { DEFAULT_LOCAL_DEV_PORT, resolveLocalBuildType, runLocalApp };
+export { DEFAULT_LOCAL_DEV_PORT, runLocalApp };

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

@@ -1,64 +1,102 @@
-import { CliError } from "../../shell/errors.js";
 import { readBunPackageJson } from "./bun-project.js";
-import { readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { sourceRootLineage } from "@prisma/compute-sdk/config";
+import { readFile, readdir, stat } from "node:fs/promises";
 import path from "node:path";
 import { exec } from "node:child_process";
 import { parseModule } from "magicast";
 //#region src/lib/app/preview-build-settings.ts
+/** Legacy build-settings file: no longer read or written, only detected for migration. */
 const PRISMA_APP_CONFIG_FILENAME = "prisma.app.json";
-const PRISMA_APP_CONFIG_SCHEMA_URL = "https://pris.ly/schemas/prisma-app-config.v1.json";
-async function resolveOrCreatePreviewBuildSettings(options) {
+/**
+* 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);
-	const existing = await readPreviewBuildSettingsConfig(configPath, options.signal);
-	if (existing) return {
-		status: "used",
-		configPath,
-		relativeConfigPath: PRISMA_APP_CONFIG_FILENAME,
-		settings: {
-			buildCommand: existing.buildCommand,
-			buildCommandSource: null,
-			outputDirectory: existing.outputDirectory,
-			outputDirectorySource: null
-		}
-	};
-	const settings = await resolvePreviewBuildSettings(options);
-	const config = {
-		$schema: PRISMA_APP_CONFIG_SCHEMA_URL,
-		buildCommand: settings.buildCommand,
-		outputDirectory: settings.outputDirectory
-	};
+	let content;
 	try {
-		await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, {
+		options.signal?.throwIfAborted();
+		content = await readFile(configPath, {
 			encoding: "utf8",
-			flag: "wx",
 			signal: options.signal
 		});
 	} catch (error) {
-		if (error.code === "EEXIST") {
-			const raced = await readPreviewBuildSettingsConfig(configPath, options.signal);
-			if (raced) return {
-				status: "used",
-				configPath,
-				relativeConfigPath: PRISMA_APP_CONFIG_FILENAME,
-				settings: {
-					buildCommand: raced.buildCommand,
-					buildCommandSource: null,
-					outputDirectory: raced.outputDirectory,
-					outputDirectorySource: null
-				}
-			};
-		}
-		throw error;
+		if (options.signal?.aborted) throw error;
+		return { kind: "absent" };
 	}
-	return {
-		status: "created",
+	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,
-		relativeConfigPath: PRISMA_APP_CONFIG_FILENAME,
-		settings
+		...legacy
+	};
+}
+/** Resolves build settings purely from framework inference; nothing is read or written. */
+async function resolveInferredPreviewBuildSettings(options) {
+	return {
+		status: "inferred",
+		configPath: null,
+		relativeConfigPath: null,
+		settings: await resolvePreviewBuildSettings(options)
+	};
+}
+/**
+* Resolves build settings when the compute config owns them: configured
+* fields win, omitted fields fall back to framework defaults.
+*/
+async function resolveConfiguredPreviewBuildSettings(options) {
+	const configFilename = path.basename(options.configPath);
+	const source = `set by ${configFilename}`;
+	const fallback = options.configured.command === void 0 || options.configured.outputDirectory === void 0 ? await resolvePreviewBuildSettings(options) : null;
+	return {
+		status: "config",
+		configPath: options.configPath,
+		relativeConfigPath: configFilename,
+		settings: {
+			buildCommand: options.configured.command !== void 0 ? options.configured.command : fallback.buildCommand,
+			buildCommandSource: options.configured.command !== void 0 ? source : fallback.buildCommandSource,
+			outputDirectory: options.configured.outputDirectory ?? fallback.outputDirectory,
+			outputDirectorySource: options.configured.outputDirectory !== void 0 ? source : fallback.outputDirectorySource
+		}
 	};
 }
 async function resolvePreviewBuildSettings(options) {
 	switch (options.buildType) {
+		case "nuxt": return {
+			buildCommand: "nuxt build",
+			buildCommandSource: "Nuxt default",
+			outputDirectory: ".output",
+			outputDirectorySource: "Nuxt output"
+		};
+		case "astro": return {
+			buildCommand: "astro build",
+			buildCommandSource: "Astro default",
+			outputDirectory: "dist",
+			outputDirectorySource: "Astro output"
+		};
 		case "nextjs": {
 			const packageJson = await readBunPackageJson(options.appPath, options.signal);
 			const buildCommand = await resolveFrameworkBuildCommand(options.appPath, packageJson, {
@@ -104,57 +142,6 @@ async function resolvePreviewBuildSettings(options) {
 		}
 	}
 }
-async function readPreviewBuildSettingsConfig(configPath, signal) {
-	let content;
-	try {
-		content = await readFile(configPath, {
-			encoding: "utf8",
-			signal
-		});
-	} catch (error) {
-		if (error.code === "ENOENT") return null;
-		throw error;
-	}
-	let parsed;
-	try {
-		parsed = JSON.parse(content);
-	} catch (error) {
-		throw invalidPrismaAppConfigError(configPath, `The file is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw invalidPrismaAppConfigError(configPath, "The file must contain a JSON object.");
-	const raw = parsed;
-	if ("$schema" in raw && raw.$schema !== void 0 && typeof raw.$schema !== "string") throw invalidPrismaAppConfigError(configPath, "The $schema field must be a string when present.");
-	if (raw.buildCommand !== null && typeof raw.buildCommand !== "string") throw invalidPrismaAppConfigError(configPath, "The buildCommand field must be a string or null.");
-	let buildCommand = null;
-	if (typeof raw.buildCommand === "string") {
-		buildCommand = raw.buildCommand.trim();
-		if (buildCommand.length === 0) throw invalidPrismaAppConfigError(configPath, "The buildCommand field must not be an empty string. Use null to skip the build step.");
-	}
-	const outputDirectory = normalizeConfigOutputDirectory(configPath, raw.outputDirectory);
-	return {
-		buildCommand,
-		outputDirectory
-	};
-}
-function normalizeConfigOutputDirectory(configPath, value) {
-	if (typeof value !== "string" || value.trim().length === 0) throw invalidPrismaAppConfigError(configPath, "The outputDirectory field must be a non-empty string.");
-	const normalized = normalizeRelativePath(value);
-	if (!normalized) throw invalidPrismaAppConfigError(configPath, "The outputDirectory field must be a relative path inside the app directory.");
-	return normalized;
-}
-function invalidPrismaAppConfigError(configPath, why) {
-	return new CliError({
-		code: "APP_CONFIG_INVALID",
-		domain: "app",
-		summary: `Invalid ${PRISMA_APP_CONFIG_FILENAME}`,
-		why,
-		fix: `Edit ${PRISMA_APP_CONFIG_FILENAME} so buildCommand is a string or null and outputDirectory is a relative path inside the app root. Delete the file and rerun prisma-cli app deploy to regenerate defaults.`,
-		where: configPath,
-		meta: { configPath },
-		exitCode: 2,
-		nextSteps: ["prisma-cli app deploy"]
-	});
-}
 async function hasRootFile(appPath, filenames, signal) {
 	let entries;
 	try {
@@ -203,12 +190,14 @@ function readBuildScript(packageJson) {
 	return buildScript.length > 0 ? buildScript : null;
 }
 async function resolvePackageManager(appPath, packageJson, signal) {
-	const fromPackageManager = packageManagerFromPackageJson(packageJson?.packageManager);
-	if (fromPackageManager) return fromPackageManager;
-	if (await pathExists(path.join(appPath, "bun.lock"), signal) || await pathExists(path.join(appPath, "bun.lockb"), signal)) return "bun";
-	if (await pathExists(path.join(appPath, "pnpm-lock.yaml"), signal)) return "pnpm";
-	if (await pathExists(path.join(appPath, "yarn.lock"), signal)) return "yarn";
-	if (await pathExists(path.join(appPath, "package-lock.json"), signal)) return "npm";
+	for (const directory of await sourceRootLineage(appPath, signal)) {
+		const fromPackageManager = packageManagerFromPackageJson((directory === path.resolve(appPath) ? packageJson : await readBunPackageJson(directory, signal))?.packageManager);
+		if (fromPackageManager) return fromPackageManager;
+		if (await pathExists(path.join(directory, "bun.lock"), signal) || await pathExists(path.join(directory, "bun.lockb"), signal)) return "bun";
+		if (await pathExists(path.join(directory, "pnpm-lock.yaml"), signal)) return "pnpm";
+		if (await pathExists(path.join(directory, "yarn.lock"), signal)) return "yarn";
+		if (await pathExists(path.join(directory, "package-lock.json"), signal)) return "npm";
+	}
 }
 function packageManagerFromPackageJson(value) {
 	if (typeof value !== "string") return null;
@@ -217,15 +206,16 @@ function packageManagerFromPackageJson(value) {
 }
 async function runResolvedBuildCommand(appPath, settings, failurePrefix, signal) {
 	if (!settings.buildCommand) return;
-	await execBuildCommand(settings.buildCommand, appPath, failurePrefix, signal);
+	const binDirs = (await sourceRootLineage(appPath, signal)).map((directory) => path.join(directory, "node_modules", ".bin"));
+	await execBuildCommand(settings.buildCommand, appPath, binDirs, failurePrefix, signal);
 }
-function execBuildCommand(command, cwd, failurePrefix, signal) {
+function execBuildCommand(command, cwd, binDirs, failurePrefix, signal) {
 	return new Promise((resolve, reject) => {
 		const child = exec(command, {
 			cwd,
 			env: {
 				...process.env,
-				PATH: [path.join(cwd, "node_modules", ".bin"), process.env.PATH].filter(Boolean).join(path.delimiter)
+				PATH: [...binDirs, process.env.PATH].filter(Boolean).join(path.delimiter)
 			},
 			maxBuffer: 10 * 1024 * 1024,
 			signal
@@ -365,6 +355,7 @@ function propertyKeyName(value) {
 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;
@@ -382,4 +373,4 @@ async function pathExists(targetPath, signal) {
 	}
 }
 //#endregion
-export { PRISMA_APP_CONFIG_FILENAME, PRISMA_APP_CONFIG_SCHEMA_URL, hasAnyPackageDependency, hasPackageDependency, hasRootFile, joinPosix, nextOutputRootFromStandaloneDirectory, resolveOrCreatePreviewBuildSettings, resolvePreviewBuildSettings, runResolvedBuildCommand };
+export { PRISMA_APP_CONFIG_FILENAME, detectLegacyBuildSettings, hasAnyPackageDependency, hasPackageDependency, hasRootFile, joinPosix, nextOutputRootFromStandaloneDirectory, resolveConfiguredPreviewBuildSettings, resolveInferredPreviewBuildSettings, resolvePreviewBuildSettings, runResolvedBuildCommand };

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

@@ -1,6 +1,7 @@
 import { readBunPackageJson, resolveBunEntrypoint } from "./bun-project.js";
-import { PRISMA_APP_CONFIG_FILENAME, hasAnyPackageDependency, hasPackageDependency, hasRootFile, joinPosix, nextOutputRootFromStandaloneDirectory, resolvePreviewBuildSettings, runResolvedBuildCommand } from "./preview-build-settings.js";
-import { chmod, copyFile, cp, lstat, mkdir, mkdtemp, readFile, readdir, readlink, rm, stat, writeFile } from "node:fs/promises";
+import { hasAnyPackageDependency, hasPackageDependency, hasRootFile, joinPosix, nextOutputRootFromStandaloneDirectory, resolvePreviewBuildSettings, runResolvedBuildCommand } from "./preview-build-settings.js";
+import { resolveSourceRoot } from "@prisma/compute-sdk/config";
+import { chmod, copyFile, cp, lstat, mkdir, mkdtemp, readdir, readlink, rm, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import os from "node:os";
 import { AstroBuild, BunBuild, NuxtBuild } from "@prisma/compute-sdk";
@@ -246,7 +247,7 @@ var PreviewTanstackStartBuild = class {
 		const outputDir = path.join(this.#appPath, settings.outputDirectory);
 		const entrypoint = "server/index.mjs";
 		const entryPath = path.join(outputDir, entrypoint);
-		if (!(await unsupportedFilesystemBoundary(signal, () => stat(entryPath).catch(() => null)))?.isFile()) throw new Error(`TanStack Start build did not produce a Nitro node server entrypoint at ${joinPosix(settings.outputDirectory, entrypoint)}. Ensure your vite.config includes the tanstackStart() and nitro() plugins with the default node preset, or update ${PRISMA_APP_CONFIG_FILENAME}.`);
+		if (!(await unsupportedFilesystemBoundary(signal, () => stat(entryPath).catch(() => null)))?.isFile()) throw new Error(`TanStack Start build did not produce a Nitro node server entrypoint at ${joinPosix(settings.outputDirectory, entrypoint)}. Ensure your vite.config includes the tanstackStart() and nitro() plugins with the default node preset, or set build.outputDirectory in prisma.compute.ts.`);
 		const outDir = await unsupportedFilesystemBoundary(signal, () => mkdtemp(path.join(os.tmpdir(), "compute-build-")));
 		try {
 			const artifactDir = path.join(outDir, "app");
@@ -315,7 +316,7 @@ async function stageNextjsStandaloneArtifact(options) {
 		sourceRoot: await resolveSourceRoot(appRoot, options.signal),
 		signal: options.signal
 	});
-	await hoistPnpmDependencies(path.join(artifactRoot, "node_modules"), options.signal);
+	await hoistIsolatedStoreDependencies(path.join(artifactRoot, "node_modules"), options.signal);
 }
 async function copyNextjsStaticAssets(options) {
 	const serverSubpath = nextjsServerSubpath(options.entrypoint);
@@ -357,12 +358,21 @@ function nextjsServerSubpath(entrypoint) {
 	const dir = path.posix.dirname(entrypoint);
 	return dir === "." ? "" : dir;
 }
-async function hoistPnpmDependencies(nodeModulesDir, signal) {
-	const pnpmNodeModulesDir = path.join(nodeModulesDir, ".pnpm", "node_modules");
-	if (!await directoryExists(pnpmNodeModulesDir, signal)) return;
-	const entries = await unsupportedFilesystemBoundary(signal, () => readdir(pnpmNodeModulesDir, { withFileTypes: true }));
+/**
+* pnpm and bun (isolated linker) both keep packages in a virtual store with a
+* shared symlink farm (`.pnpm/node_modules`, `.bun/node_modules`). Hoist the
+* farm entries to the artifact's node_modules root so Node-style resolution
+* works after symlinks are materialized.
+*/
+async function hoistIsolatedStoreDependencies(nodeModulesDir, signal) {
+	await hoistStoreDependencies(nodeModulesDir, path.join(nodeModulesDir, ".pnpm", "node_modules"), signal);
+	await hoistStoreDependencies(nodeModulesDir, path.join(nodeModulesDir, ".bun", "node_modules"), signal);
+}
+async function hoistStoreDependencies(nodeModulesDir, storeNodeModulesDir, signal) {
+	if (!await directoryExists(storeNodeModulesDir, signal)) return;
+	const entries = await unsupportedFilesystemBoundary(signal, () => readdir(storeNodeModulesDir, { withFileTypes: true }));
 	for (const entry of entries) {
-		const sourcePath = path.join(pnpmNodeModulesDir, entry.name);
+		const sourcePath = path.join(storeNodeModulesDir, entry.name);
 		if (entry.name.startsWith("@") && entry.isDirectory()) {
 			const scopedEntries = await unsupportedFilesystemBoundary(signal, () => readdir(sourcePath, { withFileTypes: true }));
 			for (const scopedEntry of scopedEntries) {
@@ -370,7 +380,7 @@ async function hoistPnpmDependencies(nodeModulesDir, signal) {
 				if (await pathExists(scopedDestination, signal)) continue;
 				await unsupportedFilesystemBoundary(signal, () => mkdir(path.dirname(scopedDestination), { recursive: true }));
 				await copyPathMaterializingSymlinks(path.join(sourcePath, scopedEntry.name), scopedDestination, {
-					standaloneRoot: pnpmNodeModulesDir,
+					standaloneRoot: storeNodeModulesDir,
 					appRoot: nodeModulesDir,
 					sourceRoot: nodeModulesDir,
 					signal
@@ -381,7 +391,7 @@ async function hoistPnpmDependencies(nodeModulesDir, signal) {
 		const destinationPath = path.join(nodeModulesDir, entry.name);
 		if (await pathExists(destinationPath, signal)) continue;
 		await copyPathMaterializingSymlinks(sourcePath, destinationPath, {
-			standaloneRoot: pnpmNodeModulesDir,
+			standaloneRoot: storeNodeModulesDir,
 			appRoot: nodeModulesDir,
 			sourceRoot: nodeModulesDir,
 			signal
@@ -401,31 +411,23 @@ async function normalizeArtifactSymlinks(artifactDir, appPath, signal) {
 				continue;
 			}
 			if (!entry.isSymbolicLink()) continue;
-			if (await materializeArtifactSymlink({
-				fullPath,
-				normalizedArtifactDir,
-				normalizedAppPath,
-				signal
-			}) === "directory") await walkDirectory(fullPath);
+			const target = await unsupportedFilesystemBoundary(signal, () => readlink(fullPath));
+			const resolvedTarget = path.resolve(path.dirname(fullPath), target);
+			if (isPathWithin(normalizedArtifactDir, resolvedTarget)) continue;
+			if (!isPathWithin(normalizedAppPath, resolvedTarget)) throw new Error(`Build artifact symlink escapes the app directory: ${resolvedTarget}`);
+			const targetStat = await unsupportedFilesystemBoundary(signal, () => stat(resolvedTarget));
+			await unsupportedFilesystemBoundary(signal, () => rm(fullPath, {
+				force: true,
+				recursive: true
+			}));
+			await unsupportedFilesystemBoundary(signal, () => cp(resolvedTarget, fullPath, {
+				recursive: targetStat.isDirectory(),
+				dereference: true
+			}));
+			if (targetStat.isDirectory()) await walkDirectory(fullPath);
 		}
 	}
 }
-async function materializeArtifactSymlink(options) {
-	const target = await unsupportedFilesystemBoundary(options.signal, () => readlink(options.fullPath));
-	const resolvedTarget = path.resolve(path.dirname(options.fullPath), target);
-	if (isPathWithin(options.normalizedArtifactDir, resolvedTarget)) return "internal";
-	if (!isPathWithin(options.normalizedAppPath, resolvedTarget)) throw new Error(`Build artifact symlink escapes the app directory: ${resolvedTarget}`);
-	const targetStat = await unsupportedFilesystemBoundary(options.signal, () => stat(resolvedTarget));
-	await unsupportedFilesystemBoundary(options.signal, () => rm(options.fullPath, {
-		force: true,
-		recursive: true
-	}));
-	await unsupportedFilesystemBoundary(options.signal, () => cp(resolvedTarget, options.fullPath, {
-		recursive: targetStat.isDirectory(),
-		dereference: true
-	}));
-	return targetStat.isDirectory() ? "directory" : "file";
-}
 function isPathWithin(rootPath, candidatePath) {
 	const relativePath = path.relative(rootPath, candidatePath);
 	return relativePath === "" || !relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath);
@@ -489,29 +491,6 @@ async function directoryExists(targetPath, signal) {
 		return false;
 	}
 }
-async function resolveSourceRoot(appRoot, signal) {
-	let current = path.resolve(appRoot);
-	while (true) {
-		if (await pathExists(path.join(current, ".git"), signal) || await pathExists(path.join(current, "pnpm-workspace.yaml"), signal) || await pathExists(path.join(current, "bun.lock"), signal) || await pathExists(path.join(current, "bun.lockb"), signal) || await packageJsonDeclaresWorkspaces(current, signal)) return current;
-		const parent = path.dirname(current);
-		if (parent === current) return path.resolve(appRoot);
-		current = parent;
-	}
-}
-async function packageJsonDeclaresWorkspaces(directory, signal) {
-	signal?.throwIfAborted();
-	try {
-		const content = await readFile(path.join(directory, "package.json"), {
-			encoding: "utf8",
-			signal
-		});
-		const parsed = JSON.parse(content);
-		return Boolean(parsed.workspaces);
-	} catch (error) {
-		if (signal?.aborted) throw error;
-		return false;
-	}
-}
 async function unsupportedFilesystemBoundary(signal, operation) {
 	signal?.throwIfAborted();
 	const result = await operation();

package/dist/lib/app/production-deploy-gate.js

@@ -104,12 +104,12 @@ function productionDeployRequiresFlagError() {
 			"",
 			"Production deploys require explicit intent. Re-run with:",
 			"",
-			"  prisma app deploy --prod",
+			"  prisma-cli app deploy --prod",
 			"",
 			"Or deploy a preview from a feature branch:",
 			"",
 			"  git checkout -b <branch-name>",
-			"  prisma app deploy"
+			"  prisma-cli app deploy"
 		]
 	});
 }

package/dist/lib/diagnostics.js

@@ -3,7 +3,7 @@ import { resolveStateDir } from "../shell/runtime.js";
 import { readLocalGitState } from "./git/local-status.js";
 //#region src/lib/diagnostics.ts
 async function collectCommandDiagnostics(context, options = {}) {
-	const stateDir = resolveStateDir(context.runtime);
+	const stateDir = await resolveStateDir(context.runtime);
 	return {
 		cwd: context.runtime.cwd,
 		stateFilePath: resolveLocalStateFilePath(stateDir),

package/dist/lib/fs/home-path.js

@@ -0,0 +1,24 @@
+import path from "node:path";
+//#region src/lib/fs/home-path.ts
+/**
+* Shortens a path under the user's home directory to `~/...` for display,
+* posix-style on every platform. Falls back to the Windows home variables
+* when `HOME` is unset (native cmd/PowerShell sessions).
+*/
+function shortenHomePath(value, env) {
+	const resolved = path.resolve(value);
+	const home = resolveHomeDirectory(env);
+	if (home && (resolved === home || resolved.startsWith(`${home}${path.sep}`))) {
+		const relative = path.relative(home, resolved).split(path.sep).join("/");
+		return relative ? `~/${relative}` : "~";
+	}
+	return resolved;
+}
+function resolveHomeDirectory(env) {
+	if (env.HOME) return path.resolve(env.HOME);
+	if (env.USERPROFILE) return path.resolve(env.USERPROFILE);
+	if (env.HOMEDRIVE && env.HOMEPATH) return path.resolve(`${env.HOMEDRIVE}${env.HOMEPATH}`);
+	return null;
+}
+//#endregion
+export { shortenHomePath };

package/dist/lib/git/local-branch.js

@@ -1,9 +1,22 @@
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
 //#region src/lib/git/local-branch.ts
+/**
+* Resolves the checked-out branch the way git does: the nearest `.git`
+* (directory or worktree file) from `cwd` upward owns the answer, so
+* monorepo commands run from inside a package see the repository branch.
+* Returns null for detached HEAD or when no repository contains `cwd`.
+*/
 async function readLocalGitBranch(cwd, signal) {
-	const headPath = await resolveGitHeadPath(path.join(cwd, ".git"), signal);
-	if (!headPath) return null;
+	for (let directory = path.resolve(cwd);;) {
+		const headPath = await resolveGitHeadPath(path.join(directory, ".git"), signal);
+		if (headPath) return readBranchFromHead(headPath, signal);
+		const parent = path.dirname(directory);
+		if (parent === directory) return null;
+		directory = parent;
+	}
+}
+async function readBranchFromHead(headPath, signal) {
 	try {
 		const head = (await readFile(headPath, {
 			encoding: "utf8",
@@ -12,7 +25,6 @@ async function readLocalGitBranch(cwd, signal) {
 		if (head.startsWith("ref: refs/heads/")) return head.slice(16);
 	} catch (error) {
 		if (signal.aborted) throw error;
-		return null;
 	}
 	return null;
 }

package/dist/lib/project/resolution.js

@@ -339,7 +339,7 @@ async function resolveBoundProjectTarget(options, projects, settings) {
 }
 async function readImplicitLocalPin(options, settings) {
 	if (options.explicitProject || settings.allowEnvProjectId && options.envProjectId) return Result.ok(null);
-	const localPinResult = await readLocalResolutionPin(options.context.runtime.cwd, options.context.runtime.signal);
+	const localPinResult = await readLocalResolutionPin(options.projectDir ?? options.context.runtime.cwd, options.context.runtime.signal);
 	if (localPinResult.isErr()) return Result.err(localPinReadErrorToProjectError(localPinResult.error));
 	const localPin = localPinResult.value;
 	if (localPin.kind === "present" && localPin.pin.workspaceId !== options.workspace.id) return Result.err(new LocalProjectWorkspaceMismatchError({

package/dist/lib/project/setup.js

@@ -1,7 +1,9 @@
 import { CliError, usageError } from "../../shell/errors.js";
+import { shortenHomePath } from "../fs/home-path.js";
 import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, ensureLocalResolutionPinGitignore, writeLocalResolutionPin } from "./local-pin.js";
 import "../../shell/command-arguments.js";
 import { projectAmbiguousError, projectNotFoundError } from "./resolution.js";
+import path from "node:path";
 import { Result, matchError } from "better-result";
 //#region src/lib/project/setup.ts
 function isValidProjectSetupName(projectName) {
@@ -13,22 +15,21 @@ function validateProjectSetupNameText(value, fallback) {
 }
 function resolveProjectForSetup(projectRef, projects, workspace) {
 	const matches = projects.filter((project) => project.id === projectRef || project.name === projectRef);
-	const match = matches[0];
-	if (matches.length === 1 && match) return match;
+	if (matches.length === 1) return matches[0];
 	if (matches.length > 1) throw projectAmbiguousError(projectRef, matches);
 	throw projectNotFoundError(projectRef, workspace);
 }
-async function bindProjectToDirectory(context, workspace, project, action) {
+async function bindProjectToDirectory(context, workspace, project, action, directory = context.runtime.cwd) {
 	return Result.gen(async function* () {
-		yield* Result.await(writeLocalResolutionPin(context.runtime.cwd, {
+		yield* Result.await(writeLocalResolutionPin(directory, {
 			workspaceId: workspace.id,
 			projectId: project.id
 		}, context.runtime.signal));
-		yield* Result.await(ensureLocalResolutionPinGitignore(context.runtime.cwd, context.runtime.signal));
+		yield* Result.await(ensureLocalResolutionPinGitignore(directory, context.runtime.signal));
 		return Result.ok({
 			workspace,
 			project,
-			directory: formatSetupDirectory(context.runtime.cwd),
+			directory: formatSetupDirectory(directory, context),
 			localPin: {
 				path: LOCAL_RESOLUTION_PIN_RELATIVE_PATH,
 				written: true
@@ -110,8 +111,9 @@ function projectCreateFailedError(error, projectName, workspace, options) {
 		nextSteps: options.nextSteps
 	});
 }
-function formatSetupDirectory(cwd) {
-	const basename = cwd.split(/[\\/]/).filter(Boolean).pop();
+function formatSetupDirectory(directory, context) {
+	if (path.resolve(directory) !== path.resolve(context.runtime.cwd)) return shortenHomePath(directory, context.runtime.env);
+	const basename = directory.split(/[\\/]/).filter(Boolean).pop();
 	return basename ? `./${basename}` : ".";
 }
 function extractHttpStatus(error) {