@prisma/cli 3.0.0-dev.87.1 → 3.0.0-dev.90.1

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 };

package/dist/lib/app/bun-project.js

@@ -21,13 +21,12 @@ async function readBunPackageJson(appPath, signal) {
 	}
 }
 function readBunPackageEntrypoint(packageJson) {
-	if (typeof packageJson?.main === "string") return packageJson.main;
-	if (typeof packageJson?.module === "string") return packageJson.module;
+	return typeof packageJson?.main === "string" ? packageJson.main : void 0;
 }
 async function resolveBunEntrypoint(appPath, explicitEntrypoint, signal) {
 	const packageJson = await readBunPackageJson(appPath, signal);
 	const candidate = explicitEntrypoint ?? readBunPackageEntrypoint(packageJson);
-	if (!candidate) throw new Error("Entrypoint is required. Pass --entry or define package.json main or module.");
+	if (!candidate) throw new Error("Entrypoint is required. Pass --entry or define package.json main.");
 	if (path.isAbsolute(candidate)) throw new Error("Entrypoint must be a relative path.");
 	const normalized = path.normalize(candidate);
 	if (normalized.startsWith("..") || path.isAbsolute(normalized) || normalized.includes(`${path.sep}..${path.sep}`)) throw new Error("Entrypoint must not escape the app directory.");

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

@@ -0,0 +1,147 @@
+import { CliError } from "../../shell/errors.js";
+import { COMPUTE_CONFIG_FILENAME, COMPUTE_CONFIG_FILENAME as COMPUTE_CONFIG_FILENAME$1, ComputeConfigTargetRequiredError, computeTargetAppDir, frameworkByKey, inferComputeTargetFromCwd, loadComputeConfig, selectComputeDeployTarget } from "@prisma/compute-sdk/config";
+import path from "node:path";
+import { matchError } from "better-result";
+//#region src/lib/app/compute-config.ts
+/**
+* Loads the nearest compute config, searching from `cwd` up to the source
+* root (repository or workspace boundary). Thin adapter over the SDK loader
+* keeping the CLI's positional-signal call shape.
+*/
+async function loadComputeConfig$1(cwd, signal) {
+	return loadComputeConfig(cwd, { signal });
+}
+/** Local build/run strategy implied by a configured framework. */
+function computeFrameworkToBuildType(framework) {
+	return frameworkByKey(framework).buildType;
+}
+function mergeComputeDeployInputs(options) {
+	const { cli, target, configFilename } = options;
+	const configAnnotation = `set by ${configFilename}`;
+	const framework = cli.framework ? {
+		value: cli.framework,
+		annotation: "set by --framework"
+	} : target?.framework ? {
+		value: target.framework,
+		annotation: configAnnotation
+	} : void 0;
+	const entrypoint = cli.entrypoint ? {
+		value: cli.entrypoint,
+		annotation: "set by --entry"
+	} : target?.entry ? {
+		value: target.entry,
+		annotation: configAnnotation
+	} : void 0;
+	const httpPort = cli.httpPort ? {
+		value: cli.httpPort,
+		annotation: "set by --http-port"
+	} : target?.httpPort ? {
+		value: String(target.httpPort),
+		annotation: configAnnotation
+	} : void 0;
+	const cliEnvInputs = cli.envInputs && cli.envInputs.length > 0 ? cli.envInputs : void 0;
+	const configEnvInputs = target && target.envInputs.length > 0 ? target.envInputs : void 0;
+	const envInputs = cliEnvInputs ?? configEnvInputs;
+	const configAppName = target?.name ? {
+		value: target.name,
+		annotation: configAnnotation
+	} : target?.key ? {
+		value: target.key,
+		annotation: configAnnotation
+	} : void 0;
+	return {
+		framework,
+		entrypoint,
+		httpPort,
+		envInputs,
+		envInputsFromConfig: !cliEnvInputs && configEnvInputs !== void 0,
+		configAppName,
+		appRoot: target?.root ?? void 0
+	};
+}
+/**
+* Merges CLI inputs for the local `app build` and `app run` commands with a
+* selected config target. Explicit flags win; `--build-type auto` is the
+* flag default and defers to the configured framework.
+*/
+function mergeComputeLocalInputs(options) {
+	const { cli, target } = options;
+	const cliBuildType = cli.buildType && cli.buildType !== "auto" ? cli.buildType : void 0;
+	const configBuildType = target?.framework ? computeFrameworkToBuildType(target.framework) : void 0;
+	return {
+		entrypoint: cli.entrypoint ?? target?.entry ?? void 0,
+		buildType: cliBuildType ?? configBuildType,
+		buildTypeFromConfig: !cliBuildType && configBuildType !== void 0,
+		port: cli.port ?? (target?.httpPort ? String(target.httpPort) : void 0),
+		appRoot: target?.root ?? void 0
+	};
+}
+function computeConfigErrorToCliError(error, commandName = "deploy") {
+	const command = `prisma-cli app ${commandName}`;
+	return matchError(error, {
+		ComputeConfigAmbiguousError: (ambiguous) => new CliError({
+			code: "COMPUTE_CONFIG_INVALID",
+			domain: "app",
+			summary: "Multiple compute config files found",
+			why: ambiguous.message,
+			fix: `Keep exactly one compute config file, preferably ${COMPUTE_CONFIG_FILENAME}.`,
+			meta: { configPaths: ambiguous.configPaths },
+			exitCode: 2,
+			nextSteps: [command]
+		}),
+		ComputeConfigLoadError: (load) => new CliError({
+			code: "COMPUTE_CONFIG_INVALID",
+			domain: "app",
+			summary: `Could not load ${path.basename(load.configPath)}`,
+			why: load.message,
+			fix: `Fix the error in ${path.basename(load.configPath)} and rerun the command.`,
+			where: load.configPath,
+			meta: { configPath: load.configPath },
+			exitCode: 2,
+			nextSteps: [command]
+		}),
+		ComputeConfigInvalidError: (invalid) => new CliError({
+			code: "COMPUTE_CONFIG_INVALID",
+			domain: "app",
+			summary: `Invalid ${path.basename(invalid.configPath)}`,
+			why: invalid.issues.join(" "),
+			fix: `Edit ${path.basename(invalid.configPath)} so it default-exports defineComputeConfig({ app }) or defineComputeConfig({ apps }).`,
+			where: invalid.configPath,
+			meta: {
+				configPath: invalid.configPath,
+				issues: invalid.issues
+			},
+			exitCode: 2,
+			nextSteps: [command]
+		}),
+		ComputeConfigTargetRequiredError: (required) => new CliError({
+			code: "COMPUTE_CONFIG_TARGET_REQUIRED",
+			domain: "app",
+			summary: "App target required",
+			why: required.message,
+			fix: `Pass the app target, for example ${command} <target>.`,
+			meta: {
+				configPath: required.configPath,
+				availableTargets: required.availableTargets
+			},
+			exitCode: 2,
+			nextSteps: required.availableTargets.map((target) => `${command} ${target}`)
+		}),
+		ComputeConfigTargetUnknownError: (unknown) => new CliError({
+			code: "COMPUTE_CONFIG_TARGET_UNKNOWN",
+			domain: "app",
+			summary: `Unknown app target "${unknown.requestedTarget}"`,
+			why: unknown.message,
+			fix: unknown.availableTargets.length > 0 ? `Pass one of the configured targets: ${unknown.availableTargets.join(", ")}.` : "Remove the target argument; this config defines a single app.",
+			meta: {
+				configPath: unknown.configPath,
+				requestedTarget: unknown.requestedTarget,
+				availableTargets: unknown.availableTargets
+			},
+			exitCode: 2,
+			nextSteps: unknown.availableTargets.length > 0 ? unknown.availableTargets.map((target) => `${command} ${target}`) : [command]
+		})
+	});
+}
+//#endregion
+export { COMPUTE_CONFIG_FILENAME$1 as COMPUTE_CONFIG_FILENAME, ComputeConfigTargetRequiredError, computeConfigErrorToCliError, computeFrameworkToBuildType, computeTargetAppDir, inferComputeTargetFromCwd, loadComputeConfig$1 as loadComputeConfig, mergeComputeDeployInputs, mergeComputeLocalInputs, selectComputeDeployTarget };

package/dist/lib/app/deploy-plan.js

@@ -0,0 +1,58 @@
+//#region src/lib/app/deploy-plan.ts
+/**
+* Decides whether a deploy covers one app or the whole system. A multi-app
+* config with no target named or inferred deploys every target in declaration
+* order; everything else (single-app config, an explicit/inferred target, or
+* no config at all) is a single deploy.
+*/
+function planAppDeploy(options) {
+	const { config, requestedTarget, hasCreateProject } = options;
+	if (!(config !== null && config.kind === "multi" && !requestedTarget && config.targets.length > 1)) return { mode: "single" };
+	const total = config.targets.length;
+	return {
+		mode: "all",
+		targets: config.targets.map((target, index) => ({
+			targetKey: target.key,
+			index,
+			total,
+			bindsCreateProject: index === 0 && hasCreateProject
+		}))
+	};
+}
+/**
+* Names the per-app inputs present in a deploy-all invocation, in the order
+* they should be reported. An empty list means the run is unambiguous; the
+* caller renders the usage error when it is not.
+*/
+function perAppInputsForDeployAll(inputs) {
+	return [
+		["--app", inputs.appName],
+		["--framework", inputs.framework],
+		["--entry", inputs.entrypoint],
+		["--http-port", inputs.httpPort],
+		["--env", inputs.envAssignments?.length ? inputs.envAssignments : void 0],
+		[inputs.appIdEnvVar.name, inputs.appIdEnvVar.value]
+	].filter(([, value]) => value !== void 0).map(([flag]) => flag);
+}
+/**
+* Describes a deploy-all run that stopped at the first failing target: which
+* targets already went live and which were never attempted, so the caller can
+* surface a converge path. Pure; the caller folds this into the CliError.
+*/
+function describeDeployAllFailure(options) {
+	const { targetKeys, failedIndex, completed } = options;
+	const failedTarget = targetKeys[failedIndex];
+	const notAttempted = targetKeys.slice(failedIndex + 1);
+	return {
+		failedTarget,
+		completed,
+		notAttempted,
+		contextLines: [
+			`Deploying all apps stopped at "${failedTarget}" (${failedIndex + 1}/${targetKeys.length}).`,
+			...completed.length > 0 ? [`Already live: ${completed.map((entry) => entry.target).join(", ")}.`] : [],
+			...notAttempted.length > 0 ? [`Not attempted: ${notAttempted.join(", ")}.`] : []
+		]
+	};
+}
+//#endregion
+export { describeDeployAllFailure, perAppInputsForDeployAll, planAppDeploy };

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

@@ -1,6 +1,6 @@
 import { renderDeployOutputRows } from "./deploy-output.js";
-//#region src/lib/app/preview-progress.ts
-function createPreviewDeployProgressState() {
+//#region src/lib/app/deploy-progress.ts
+function createDeployProgressState() {
 	return {
 		buildStarted: false,
 		buildCompleted: false,
@@ -13,7 +13,7 @@ function createPreviewDeployProgressState() {
 		promotedUrl: null
 	};
 }
-function createPreviewDeployProgress(output, ui, enabled, state = createPreviewDeployProgressState()) {
+function createDeployProgress(output, ui, enabled, state = createDeployProgressState()) {
 	const write = (line) => {
 		if (!enabled) return;
 		output.write(`${line}\n`);
@@ -63,7 +63,7 @@ function createPreviewDeployProgress(output, ui, enabled, state = createPreviewD
 function formatArtifactSize(byteLength) {
 	return `${(byteLength / 1024 / 1024).toFixed(1)} MB`;
 }
-function createPreviewPromoteProgress(output, enabled) {
+function createPromoteProgress(output, enabled) {
 	if (!enabled) return;
 	const write = (line) => {
 		output.write(`${line}\n`);
@@ -97,4 +97,4 @@ function createPreviewPromoteProgress(output, enabled) {
 	};
 }
 //#endregion
-export { createPreviewDeployProgress, createPreviewDeployProgressState, createPreviewPromoteProgress };
+export { createDeployProgress, createDeployProgressState, createPromoteProgress };

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/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) {