create-prisma 0.13.1 → 0.13.2-pr.111.376.1

package/README.md

@@ -21,8 +21,8 @@ does not include this runtime itself. MongoDB and Deno-only apps do not need it.
 
 For npm, use 11.6.0 or newer, which includes the [upstream resolver fix](https://github.com/npm/cli/pull/8448).
 Older npm releases can crash resolving the dependency tree (`Cannot read properties of null (reading 'edgesOut')`). Run
-`npm install --global npm@11` to update. create-prisma checks the selected npm
-version before writing project files and never upgrades your package manager automatically.
+`npm install --global npm@11` to update. create-prisma checks the selected package manager
+before writing project files and never upgrades your package manager automatically. Yarn 1 is not supported.
 
 The deployment prompt is:
 
@@ -110,4 +110,4 @@ bun run build
 
 ## Telemetry
 
-Published builds may send anonymous usage telemetry. It never includes project names, file paths, or database URLs. Disable it with `DO_NOT_TRACK`, `CREATE_PRISMA_DISABLE_TELEMETRY`, or `CREATE_PRISMA_TELEMETRY_DISABLED`.
+Published builds may send anonymous usage telemetry. It never includes project names, file paths, or database URLs. Failure events carry only stable identifiers such as exit codes and tool error codes, never messages or command output. Disable it with `DO_NOT_TRACK`, `CREATE_PRISMA_DISABLE_TELEMETRY`, or `CREATE_PRISMA_TELEMETRY_DISABLED`.

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as ApplicationLayer } from "./json-output-CPdx9Prn.mjs";
+import { a as ApplicationLayer } from "./json-output-wzlPfgC6.mjs";
 import { runCreatePrismaCli } from "./index.mjs";
 import { Effect } from "effect";
 import { NodeRuntime } from "@effect/platform-node-shared";

package/dist/index.d.mts

@@ -68,7 +68,7 @@ type CreateCommandInput = typeof CreateCommandInputSchema.Type;
 //#region src/create-outcome.d.ts
 declare const CreateFailureStageSchema: Schema.Literals<readonly ["validate_input", "collect_context", "scaffold_template", "initialize_prisma", "configure_project", "install_dependencies", "initialize_agent_skills", "emit_contract", "plan_migration", "initialize_git", "authenticate", "select_workspace", "check_project_name", "build", "composer_deploy", "unknown"]>;
 type CreateFailureStage = typeof CreateFailureStageSchema.Type;
-declare const CreateCancellationStageSchema: Schema.Literals<readonly ["project_name", "template", "database_provider", "authoring_style", "package_manager", "agent_skills", "deployment_intent", "select_workspace"]>;
+declare const CreateCancellationStageSchema: Schema.Literals<readonly ["project_name", "template", "database_provider", "authoring_style", "package_manager", "agent_skills", "deployment_intent", "authenticate", "select_workspace"]>;
 type CreateCancellationStage = typeof CreateCancellationStageSchema.Type;
 //#endregion
 //#region src/result.d.ts
@@ -124,7 +124,7 @@ declare const CreateCommandFailureResultSchema: Schema.Struct<{
   readonly schemaVersion: Schema.Literal<1>;
   readonly ok: Schema.Literal<false>;
   readonly error: Schema.Struct<{
-    readonly stage: Schema.Union<readonly [Schema.Literals<readonly ["validate_input", "collect_context", "scaffold_template", "initialize_prisma", "configure_project", "install_dependencies", "initialize_agent_skills", "emit_contract", "plan_migration", "initialize_git", "authenticate", "select_workspace", "check_project_name", "build", "composer_deploy", "unknown"]>, Schema.Literals<readonly ["project_name", "template", "database_provider", "authoring_style", "package_manager", "agent_skills", "deployment_intent", "select_workspace"]>, Schema.Literal<"parse_arguments">]>;
+    readonly stage: Schema.Union<readonly [Schema.Literals<readonly ["validate_input", "collect_context", "scaffold_template", "initialize_prisma", "configure_project", "install_dependencies", "initialize_agent_skills", "emit_contract", "plan_migration", "initialize_git", "authenticate", "select_workspace", "check_project_name", "build", "composer_deploy", "unknown"]>, Schema.Literals<readonly ["project_name", "template", "database_provider", "authoring_style", "package_manager", "agent_skills", "deployment_intent", "authenticate", "select_workspace"]>, Schema.Literal<"parse_arguments">]>;
     readonly message: Schema.String;
   }>;
   readonly project: Schema.optionalKey<Schema.Struct<{
@@ -171,7 +171,7 @@ declare const CreateCommandResultSchema: Schema.Union<readonly [Schema.Struct<{
   readonly schemaVersion: Schema.Literal<1>;
   readonly ok: Schema.Literal<false>;
   readonly error: Schema.Struct<{
-    readonly stage: Schema.Union<readonly [Schema.Literals<readonly ["validate_input", "collect_context", "scaffold_template", "initialize_prisma", "configure_project", "install_dependencies", "initialize_agent_skills", "emit_contract", "plan_migration", "initialize_git", "authenticate", "select_workspace", "check_project_name", "build", "composer_deploy", "unknown"]>, Schema.Literals<readonly ["project_name", "template", "database_provider", "authoring_style", "package_manager", "agent_skills", "deployment_intent", "select_workspace"]>, Schema.Literal<"parse_arguments">]>;
+    readonly stage: Schema.Union<readonly [Schema.Literals<readonly ["validate_input", "collect_context", "scaffold_template", "initialize_prisma", "configure_project", "install_dependencies", "initialize_agent_skills", "emit_contract", "plan_migration", "initialize_git", "authenticate", "select_workspace", "check_project_name", "build", "composer_deploy", "unknown"]>, Schema.Literals<readonly ["project_name", "template", "database_provider", "authoring_style", "package_manager", "agent_skills", "deployment_intent", "authenticate", "select_workspace"]>, Schema.Literal<"parse_arguments">]>;
     readonly message: Schema.String;
   }>;
   readonly project: Schema.optionalKey<Schema.Struct<{

package/dist/index.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { _ as authoringStyles, b as normalizeDatabaseProvider, c as CreateCommandResultSchema, d as AuthoringStyleSchema, f as CreateCommandInputSchema, g as agentSkillTargets, h as PackageManagerSchema, i as getErrorMessage, l as createCommandFailureResult, m as DatabaseProviderSchema, n as writeJsonResult, o as applicationRuntime, p as CreateTemplateSchema, r as runCreateCommandEffect, s as CREATE_PRISMA_RESULT_SCHEMA_VERSION, t as isJsonOutputRequested, u as AgentSkillTargetSchema, v as createTemplates, x as packageManagers, y as databaseProviderInputs } from "./json-output-CPdx9Prn.mjs";
+import { _ as authoringStyles, b as normalizeDatabaseProvider, c as CreateCommandResultSchema, d as AuthoringStyleSchema, f as CreateCommandInputSchema, g as agentSkillTargets, h as PackageManagerSchema, i as getErrorMessage, l as createCommandFailureResult, m as DatabaseProviderSchema, n as writeJsonResult, o as applicationRuntime, p as CreateTemplateSchema, r as runCreateCommandEffect, s as CREATE_PRISMA_RESULT_SCHEMA_VERSION, t as isJsonOutputRequested, u as AgentSkillTargetSchema, v as createTemplates, x as packageManagers, y as databaseProviderInputs } from "./json-output-wzlPfgC6.mjs";
 import { Console, Effect, Option } from "effect";
 import { Argument, CliError, Command, Flag } from "effect/unstable/cli";
 
 //#region src/index.ts
-const CLI_VERSION = "0.13.1";
+const CLI_VERSION = "0.13.2-pr.111.376.1";
 const optionalArgument = (name, description) => Argument.string(name).pipe(Argument.withDescription(description), Argument.optional, Argument.map(Option.getOrUndefined));
 const optionalBoolean = (name, description) => Flag.boolean(name).pipe(Flag.withDescription(description), Flag.optional, Flag.map(Option.getOrUndefined));
 const optionalString = (name, description) => Flag.string(name).pipe(Flag.withDescription(description), Flag.optional, Flag.map(Option.getOrUndefined));

package/dist/{json-output-CPdx9Prn.mjs → json-output-wzlPfgC6.mjs}

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
 import { Cause, Clock, Context, Effect, Exit, FileSystem, Layer, ManagedRuntime, Option, Ref, Result, Schema, SchemaTransformation } from "effect";
 import { cancel, confirm, intro, isCancel, log, note, outro, select, spinner, taskLog, text } from "@clack/prompts";
+import { statSync } from "node:fs";
+import path from "node:path";
 import { NodeChildProcessSpawner, NodeFileSystem, NodePath, NodeStdio, NodeTerminal } from "@effect/platform-node-shared";
 import { execa } from "execa";
 import { createInterface } from "node:readline";
+import { stripVTControlCharacters, styleText } from "node:util";
 import { randomUUID } from "node:crypto";
 import os from "node:os";
-import path from "node:path";
 import { PostHog } from "posthog-node";
 import Handlebars from "handlebars";
 import { fileURLToPath } from "node:url";
 import { Writable } from "node:stream";
-import { styleText } from "node:util";
 
 //#region src/utils/child-process-failure.ts
 const ChildProcessFailureSchema = Schema.Literals([
@@ -41,6 +42,27 @@ function getChildProcessFailure(error) {
 	if (typeof exitCode === "number") return "non_zero_exit";
 	return "spawn_failed";
 }
+function isFile(filePath) {
+	try {
+		return statSync(filePath, { throwIfNoEntry: false })?.isFile() === true;
+	} catch {
+		return false;
+	}
+}
+function isCommandOnWindowsPath({ command, cwd, env }) {
+	const environment = {
+		...process.env,
+		...env
+	};
+	const pathKey = Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH");
+	const directories = /[\\/]/.test(command) ? [""] : [cwd, ...(pathKey ? environment[pathKey] ?? "" : "").split(";")];
+	const extensions = ["", ...(environment.PATHEXT || ".EXE;.CMD;.BAT;.COM").split(";")];
+	return directories.some((directory) => extensions.some((extension) => isFile(path.resolve(cwd, directory.replace(/^"(.*)"$/, "$1"), command + extension))));
+}
+function getSpawnedCommandFailure(error, spawned) {
+	const failure = getChildProcessFailure(error);
+	return failure === "non_zero_exit" && (spawned.platform ?? process.platform) === "win32" && !isCommandOnWindowsPath(spawned) ? "command_not_found" : failure;
+}
 
 //#endregion
 //#region src/create-outcome.ts
@@ -66,6 +88,8 @@ const CreateFailureReasonSchema = Schema.Literals([
 	"invalid_input",
 	"unsupported_node_version",
 	"unsupported_package_manager_version",
+	"package_manager_not_found",
+	"package_manager_check_failed",
 	"invalid_project_name",
 	"target_path_not_directory",
 	"target_directory_not_empty",
@@ -99,6 +123,7 @@ const CreateCancellationStageSchema = Schema.Literals([
 	"package_manager",
 	"agent_skills",
 	"deployment_intent",
+	"authenticate",
 	"select_workspace"
 ]);
 var CreateCancellationError = class extends Schema.TaggedError()("CreateCancellationError", {
@@ -119,16 +144,22 @@ var CreateFailure = class extends Schema.TaggedError()("CreateFailure", {
 	cause: Schema.optionalKey(Schema.Defect()),
 	errorReported: Schema.optionalKey(Schema.Boolean)
 }) {};
+const STRUCTURED_ERROR_CODE_PATTERN = /^[A-Z][A-Z0-9_]*(\.[A-Z0-9_]+)+$/;
+function isStructuredErrorCode(value) {
+	return typeof value === "string" && STRUCTURED_ERROR_CODE_PATTERN.test(value);
+}
 var PrismaCliCommandError = class extends Schema.TaggedError()("PrismaCliCommandError", {
 	message: Schema.String,
 	command: Schema.optionalKey(Schema.String),
 	code: Schema.optionalKey(Schema.String),
+	causeCode: Schema.optionalKey(Schema.String),
 	stderr: Schema.optionalKey(Schema.String),
 	exitCode: Schema.optionalKey(Schema.Number),
 	childProcessFailure: Schema.optional(ChildProcessFailureSchema)
 }) {
 	prismaCliCommand = this.command;
 	prismaCliErrorCode = this.code;
+	prismaCliCauseCode = this.causeCode;
 };
 
 //#endregion
@@ -353,7 +384,7 @@ var CommandRunner = class CommandRunner extends Context.Service()("create-prisma
 					exitCode: result.exitCode ?? 1,
 					stdout: typeof result.stdout === "string" ? result.stdout : "",
 					stderr: typeof result.stderr === "string" ? result.stderr : "",
-					childProcessFailure: getChildProcessFailure(result)
+					childProcessFailure: getSpawnedCommandFailure(result, spec)
 				};
 			},
 			catch: (cause) => new CommandExecutionError({
@@ -386,22 +417,47 @@ const NodeCliLayer = Layer.provideMerge(NodeChildProcessSpawner.layer, Layer.mer
 const ApplicationLayer = Layer.merge(NodeCliLayer, CommandRunner.layer);
 const applicationRuntime = ManagedRuntime.make(ApplicationLayer);
 
+//#endregion
+//#region src/utils/package-manager-error-code.ts
+const grammars = {
+	npm: {
+		line: /^npm (?:error|ERR!) code (\S+)$/,
+		allow: /^E[A-Z0-9_]{2,40}$/
+	},
+	pnpm: {
+		line: /^(?:\[([A-Z0-9_]+)\] |\u2009([A-Z0-9_]+)\u2009 )/,
+		allow: /^(?:ERR_PNPM_[A-Z0-9_]{1,60}|E[A-Z0-9_]{2,40})$/
+	},
+	yarn: {
+		line: /^(?:➤ )?(YN\d{4}): /,
+		allow: /^YN(?!0000)\d{4}$/
+	}
+};
+function getGrammar(command) {
+	const name = command.replace(/^.*[\\/]/, "").replace(/\.(?:cmd|exe)$/i, "").toLowerCase();
+	return Object.hasOwn(grammars, name) ? grammars[name] : void 0;
+}
+function getPackageManagerErrorCode(command, output) {
+	const grammar = getGrammar(command);
+	if (!grammar) return void 0;
+	const lines = stripVTControlCharacters(`${output.stdout}\n${output.stderr}`).split(/\r?\n/);
+	for (const line of lines.reverse()) {
+		const match = grammar.line.exec(line);
+		const candidate = match?.[1] ?? match?.[2];
+		if (candidate !== void 0 && grammar.allow.test(candidate)) return candidate;
+	}
+}
+
 //#endregion
 //#region src/telemetry/client.ts
-const TELEMETRY_API_KEY = "phc_cmc85avbWyuJ2JyKdGPdv7dxXli8xLdWDBPbvIXWJfs";
+const TELEMETRY_API_KEY = "";
 const TELEMETRY_HOST = "https://us.i.posthog.com";
 const TELEMETRY_CONFIG_FILE = "telemetry.json";
 const TELEMETRY_TIMEOUT_MS = 2e3;
 const AnonymousId = Schema.String.check(Schema.isUUID(4));
 const decodeAnonymousId = Schema.decodeUnknownExit(AnonymousId);
-const isTruthyEnvValue = (value) => [
-	"1",
-	"true",
-	"yes",
-	"on"
-].includes(String(value ?? "").trim().toLowerCase());
 function shouldDisableTelemetry() {
-	return isTruthyEnvValue(process.env.CI) || isTruthyEnvValue(process.env.GITHUB_ACTIONS) || process.env.CREATE_PRISMA_DISABLE_TELEMETRY !== void 0 || process.env.CREATE_PRISMA_TELEMETRY_DISABLED !== void 0 || process.env.DO_NOT_TRACK !== void 0;
+	return true;
 }
 function getTelemetryConfigDir() {
 	if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Application Support", "create-prisma");
@@ -424,7 +480,7 @@ const getAnonymousIdEffect = Effect.fn("Telemetry.getAnonymousId")(function* ()
 	return anonymousId;
 });
 const getCommonProperties = () => ({
-	"cli-version": "0.13.1",
+	"cli-version": "0.13.2-pr.111.376.1",
 	"node-version": process.version,
 	platform: process.platform,
 	arch: process.arch
@@ -464,6 +520,7 @@ const expectedRejectionReasons = new Set([
 	"invalid_input",
 	"unsupported_node_version",
 	"unsupported_package_manager_version",
+	"package_manager_not_found",
 	"invalid_project_name",
 	"target_path_not_directory",
 	"target_directory_not_empty",
@@ -513,11 +570,18 @@ function getErrorCode(error) {
 function getChildProcessFailureProperty(error) {
 	return error instanceof CommandExecutionError || error instanceof PrismaCliCommandError ? error.childProcessFailure ?? null : null;
 }
+function getPackageManagerErrorCodeProperty(error) {
+	return error instanceof CommandExecutionError ? getPackageManagerErrorCode(error.command, error) ?? null : null;
+}
 function getPrismaCliFailureProperty(error, property) {
 	if (typeof error !== "object" || error === null) return null;
 	const value = Reflect.get(error, property);
 	return typeof value === "string" && value.length > 0 ? value : null;
 }
+function getPrismaCliCauseCodeProperty(error) {
+	const causeCode = getPrismaCliFailureProperty(error, "prismaCliCauseCode");
+	return isStructuredErrorCode(causeCode) ? causeCode : null;
+}
 const trackCreateCompletedEffect = Effect.fn("Telemetry.createCompleted")(function* (params) {
 	yield* trackCliTelemetryEffect(CREATE_PRISMA_NEXT_COMPLETED_EVENT, {
 		...getBaseCreateProperties(params.input, params.context),
@@ -535,7 +599,9 @@ const trackCreateFailedEffect = Effect.fn("Telemetry.createFailed")(function* (p
 		"error-code": getErrorCode(params.error),
 		"child-process-failure": getChildProcessFailureProperty(params.error),
 		"prisma-cli-command": getPrismaCliFailureProperty(params.error, "prismaCliCommand"),
-		"prisma-cli-error-code": getPrismaCliFailureProperty(params.error, "prismaCliErrorCode")
+		"prisma-cli-error-code": getPrismaCliFailureProperty(params.error, "prismaCliErrorCode"),
+		"prisma-cli-cause-code": getPrismaCliCauseCodeProperty(params.error),
+		"package-manager-error-code": params.stage === "install_dependencies" ? getPackageManagerErrorCodeProperty(params.error) : null
 	}).pipe(Effect.scoped, Effect.timeout(TELEMETRY_TIMEOUT_MS), Effect.catch(() => Effect.void));
 });
 const trackCreateCancelledEffect = Effect.fn("Telemetry.createCancelled")(function* (params) {
@@ -626,6 +692,20 @@ function getCreateTemplateDependencies(template, packageManager) {
 	return targets;
 }
 
+//#endregion
+//#region src/utils/errors.ts
+function redactSecrets(message) {
+	return message.replace(/\b((?:(?:prisma\+)?postgres(?:ql)?|mongodb(?:\+srv)?):\/\/)[^\s'"]+/gi, "$1<redacted>").replace(/\b([A-Z0-9_]*(?:MONGODB_(?:URL|URI)|DATABASE_URL|TOKEN|SECRET|PASSWORD|API_KEY|PRIVATE_KEY)[A-Z0-9_]*\s*=\s*)(?:"[^"]*"|'[^']*'|[^\s]+)/gi, "$1<redacted>").replace(/(\bAuthorization\s*:\s*Bearer\s+)[^\s'"]+/gi, "$1<redacted>");
+}
+function getErrorMessage(error) {
+	if (error instanceof PrismaCliCommandError) return redactSecrets(error.message);
+	if (error instanceof Error && "stderr" in error) {
+		const stderr = String(error.stderr ?? "").trim();
+		if (stderr) return redactSecrets(stderr);
+	}
+	return redactSecrets(error instanceof Error ? error.message : String(error));
+}
+
 //#endregion
 //#region src/utils/package-manager.ts
 const DENO_ALLOW_FRESH_DEPENDENCIES = "--minimum-dependency-age=0";
@@ -635,22 +715,108 @@ const packageManagerManifestValues = {
 	yarn: "yarn@4.13.0",
 	bun: "bun@1.4.1"
 };
-const verifyPackageManagerEffect = Effect.fn("PackageManager.verify")(function* (packageManager) {
-	if (packageManager !== "npm") return;
-	const version = (yield* (yield* CommandRunner).runChecked({
-		command: "npm",
-		args: ["--version"],
-		cwd: process.cwd()
-	})).stdout.trim();
-	const parts = version.split(".").map(Number);
-	if (!/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(version) || parts.some((part) => !Number.isInteger(part))) return yield* Effect.fail(/* @__PURE__ */ new Error(`Could not determine the installed npm version: ${version}`));
-	const [major, minor] = parts;
-	if (major < 11 || major === 11 && minor < 6) return yield* new CreateFailure({
+const packageManagerChecks = {
+	npm: {
+		name: "npm",
+		versionArgs: ["--version"],
+		install: "Install Node.js from https://nodejs.org to get npm",
+		minimum: {
+			version: [
+				11,
+				6,
+				0
+			],
+			guidance: "Older npm releases can crash while resolving Prisma dependencies. Run npm install --global npm@11, then retry create-prisma."
+		}
+	},
+	pnpm: {
+		name: "pnpm",
+		versionArgs: ["--version"],
+		install: "Install it from https://pnpm.io/installation"
+	},
+	yarn: {
+		name: "Yarn",
+		versionArgs: ["--version"],
+		install: "Install it with Corepack (https://yarnpkg.com/corepack)",
+		minimum: {
+			version: [
+				2,
+				0,
+				0
+			],
+			guidance: `Generated projects use ${packageManagerManifestValues.yarn}, which Yarn 1 refuses to install. Enable Corepack (https://yarnpkg.com/corepack) or install Yarn 4, then retry create-prisma, or choose another package manager with --package-manager.`
+		}
+	},
+	bun: {
+		name: "Bun",
+		versionArgs: ["--version"],
+		install: "Install it from https://bun.sh"
+	},
+	deno: {
+		name: "Deno",
+		versionArgs: ["-V"],
+		install: "Install it from https://docs.deno.com/runtime/getting_started/installation"
+	}
+};
+const PACKAGE_MANAGER_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+function parsePackageManagerVersion(packageManager, version) {
+	const prefix = `${packageManager} `;
+	const match = PACKAGE_MANAGER_VERSION_PATTERN.exec(version.startsWith(prefix) ? version.slice(prefix.length) : version);
+	if (!match) return void 0;
+	const parts = [
+		Number(match[1]),
+		Number(match[2]),
+		Number(match[3])
+	];
+	return parts.every(Number.isSafeInteger) ? parts : void 0;
+}
+function isOlderVersion(version, minimum) {
+	for (const [index, part] of version.entries()) if (part !== minimum[index]) return part < minimum[index];
+	return false;
+}
+const probePackageManagerEffect = Effect.fn("PackageManager.probe")(function* (packageManager, cwd) {
+	const runner = yield* CommandRunner;
+	const { name, versionArgs, install, minimum } = packageManagerChecks[packageManager];
+	const output = (yield* runner.runChecked({
+		command: packageManager,
+		args: versionArgs,
+		cwd
+	}).pipe(Effect.mapError((cause) => cause.childProcessFailure === "command_not_found" ? new CreateFailure({
+		stage: "validate_input",
+		reason: "package_manager_not_found",
+		message: `${name} is not installed or is not on your PATH. ${install}, then retry create-prisma, or choose another package manager with --package-manager.`,
+		cause
+	}) : new CreateFailure({
+		stage: "validate_input",
+		reason: "package_manager_check_failed",
+		message: `Could not run ${[packageManager, ...versionArgs].join(" ")}: ${getErrorMessage(cause)}`,
+		cause
+	})))).stdout.trim();
+	const version = parsePackageManagerVersion(packageManager, output);
+	if (!version) return yield* new CreateFailure({
+		stage: "validate_input",
+		reason: "package_manager_check_failed",
+		message: `Could not determine the installed ${name} version: ${output}`
+	});
+	if (minimum && isOlderVersion(version, minimum.version)) return yield* new CreateFailure({
 		stage: "validate_input",
 		reason: "unsupported_package_manager_version",
-		message: `npm ${version} is unsupported. Required: npm 11.6.0 or newer. Older npm releases can crash while resolving Prisma dependencies. Run npm install --global npm@11, then retry create-prisma.`
+		message: `${name} ${version.join(".")} is unsupported. Required: ${name} ${minimum.version.join(".")} or newer. ${minimum.guidance}`
 	});
 });
+const verifyPackageManagerEffect = Effect.fn("PackageManager.verify")(function* (packageManager) {
+	const fs = yield* FileSystem.FileSystem;
+	yield* probePackageManagerEffect(packageManager, yield* fs.makeTempDirectoryScoped({ prefix: "create-prisma-" }).pipe(Effect.tap((directory) => fs.writeFileString(path.join(directory, "package.json"), JSON.stringify({
+		name: "create-prisma-probe",
+		private: true,
+		packageManager: getPackageManagerManifestValue(packageManager)
+	}))), Effect.mapError((cause) => new CreateFailure({
+		stage: "validate_input",
+		reason: "package_manager_check_failed",
+		message: `Could not prepare a directory to check ${packageManagerChecks[packageManager].name}: ${getErrorMessage(cause)}`,
+		cause
+	}))));
+}, Effect.scoped);
 function parseUserAgent(userAgent) {
 	if (userAgent?.startsWith("pnpm")) return "pnpm";
 	if (userAgent?.startsWith("yarn")) return "yarn";
@@ -1127,20 +1293,6 @@ const installProjectDependenciesEffect = Effect.fn("Dependencies.install")(funct
 	});
 });
 
-//#endregion
-//#region src/utils/errors.ts
-function redactSecrets(message) {
-	return message.replace(/\b((?:(?:prisma\+)?postgres(?:ql)?|mongodb(?:\+srv)?):\/\/)[^\s'"]+/gi, "$1<redacted>").replace(/\b([A-Z0-9_]*(?:MONGODB_(?:URL|URI)|DATABASE_URL|TOKEN|SECRET|PASSWORD|API_KEY|PRIVATE_KEY)[A-Z0-9_]*\s*=\s*)(?:"[^"]*"|'[^']*'|[^\s]+)/gi, "$1<redacted>").replace(/(\bAuthorization\s*:\s*Bearer\s+)[^\s'"]+/gi, "$1<redacted>");
-}
-function getErrorMessage(error) {
-	if (error instanceof PrismaCliCommandError) return redactSecrets(error.message);
-	if (error instanceof Error && "stderr" in error) {
-		const stderr = String(error.stderr ?? "").trim();
-		if (stderr) return redactSecrets(stderr);
-	}
-	return redactSecrets(error instanceof Error ? error.message : String(error));
-}
-
 //#endregion
 //#region src/workflow/failure.ts
 const atCreateStage = (effect, stage, reason) => effect.pipe(Effect.mapError((error) => error instanceof CreateFailure || error instanceof CreateCancellationError ? error : new CreateFailure({
@@ -1256,7 +1408,7 @@ const ensureAuthentication = Effect.fn("Deployment.ensureAuthentication")(functi
 		cwd: options.projectDir,
 		env: process.env,
 		stdio: "inherit"
-	});
+	}).pipe(Effect.mapError((error) => error.childProcessFailure === "interrupted" || error.childProcessFailure === "cancelled" ? new CreateCancellationError({ stage: "authenticate" }) : error));
 	const authenticatedState = yield* whoami();
 	if (!authenticatedState.authenticated) return yield* new CreateFailure({
 		stage: "authenticate",
@@ -1321,10 +1473,7 @@ const selectDeploymentWorkspace = Effect.fn("Deployment.selectWorkspace")(functi
 		})),
 		output: options.output
 	}));
-	if (isCancel(selectedWorkspaceId)) {
-		yield* Effect.sync(() => cancel("Operation cancelled.", { output: options.output }));
-		return yield* new CreateCancellationError({ stage: "select_workspace" });
-	}
+	if (isCancel(selectedWorkspaceId)) return yield* new CreateCancellationError({ stage: "select_workspace" });
 	yield* Effect.sync(() => options.afterPrompt?.());
 	if (selectedWorkspaceId === activeWorkspace.id) return activeWorkspace;
 	return yield* useWorkspace({
@@ -1354,6 +1503,49 @@ function parseComposerDeployResult(result) {
 	};
 }
 
+//#endregion
+//#region src/tasks/composer/deploy-report.ts
+const ComposerRunReportSchema = Schema.fromJsonString(Schema.Struct({
+	version: Schema.Literal(1),
+	failure: Schema.NullOr(Schema.Struct({ code: Schema.String }))
+}));
+const decodeComposerRunReport = Schema.decodeUnknownOption(ComposerRunReportSchema);
+function parseComposerDeployFailureCode(report) {
+	const code = Option.getOrUndefined(decodeComposerRunReport(report))?.failure?.code;
+	return isStructuredErrorCode(code) ? code : void 0;
+}
+function withCauseCode(error, causeCode) {
+	return new PrismaCliCommandError({
+		message: error.message,
+		...error.command === void 0 ? {} : { command: error.command },
+		...error.code === void 0 ? {} : { code: error.code },
+		causeCode,
+		...error.stderr === void 0 ? {} : { stderr: error.stderr },
+		...error.exitCode === void 0 ? {} : { exitCode: error.exitCode },
+		childProcessFailure: error.childProcessFailure
+	});
+}
+const readComposerDeployFailureCode = Effect.fn("Deployment.readFailureCode")(function* (reportPath) {
+	const report = yield* (yield* FileSystem.FileSystem).readFileString(reportPath).pipe(Effect.option);
+	return Option.isSome(report) ? parseComposerDeployFailureCode(report.value) : void 0;
+});
+const runComposerDeployEffect = Effect.fn("Deployment.runComposerDeploy")(function* (options) {
+	const reportPath = yield* (yield* FileSystem.FileSystem).makeTempDirectoryScoped({ prefix: "create-prisma-deploy-" }).pipe(Effect.map((directory) => path.join(directory, "report.json")), Effect.option, Effect.map(Option.getOrUndefined));
+	return yield* runPrismaJsonCommandEffect({
+		packageManager: options.packageManager,
+		projectDir: options.projectDir,
+		args: [
+			"deploy",
+			"module.ts",
+			...reportPath ? ["--report", reportPath] : []
+		],
+		...options.onStderrLine ? { onStderrLine: options.onStderrLine } : {}
+	}).pipe(Effect.catchTag("PrismaCliCommandError", (error) => Effect.gen(function* () {
+		const causeCode = reportPath ? yield* readComposerDeployFailureCode(reportPath) : void 0;
+		return yield* Effect.fail(causeCode ? withCauseCode(error, causeCode) : error);
+	})));
+}, Effect.scoped);
+
 //#endregion
 //#region src/tasks/composer/projects.ts
 const ProjectShowResultSchema = Schema.Struct({
@@ -1493,10 +1685,9 @@ const deployNewProjectWithComposerEffect = Effect.fn("Deployment.deploy")(functi
 				deploymentLog.message(`$ ${deployCommand}`);
 			}
 		});
-		const deployment = parseComposerDeployResult(yield* atCreateStage(decodePrismaCommandResult(ComposerDeployCommandResultSchema, yield* atCreateStage(runPrismaJsonCommandEffect({
+		const deployment = parseComposerDeployResult(yield* atCreateStage(decodePrismaCommandResult(ComposerDeployCommandResultSchema, yield* atCreateStage(runComposerDeployEffect({
 			packageManager: options.packageManager,
 			projectDir: options.projectDir,
-			args: ["deploy", "module.ts"],
 			onStderrLine: (line) => {
 				const redacted = redactSecrets(line);
 				if (options.verbose) output.write(`${redacted}\n`);
@@ -1528,12 +1719,17 @@ const deployNewProjectWithComposerEffect = Effect.fn("Deployment.deploy")(functi
 		};
 	}).pipe(Effect.tapCause((cause) => Effect.sync(() => {
 		const error = Cause.squash(cause);
+		if (error instanceof CreateCancellationError) {
+			clearProgress();
+			cancel(error.message ?? "Operation cancelled.", { output });
+			return;
+		}
 		if (deploymentLog) {
 			deploymentLog.error("Deployment failed.");
 			deploymentLog = void 0;
 		} else progress?.error("Deployment failed.");
 		progressRunning = false;
-		if (!(error instanceof CreateCancellationError)) log.error(`Deploy failed: ${getErrorMessage(error)}`, { output });
+		log.error(`Deploy failed: ${getErrorMessage(error)}`, { output });
 	})), Effect.mapError((error) => error instanceof CreateFailure ? new CreateFailure({
 		stage: error.stage,
 		reason: error.reason,
@@ -2285,7 +2481,7 @@ const createProjectEffect = Effect.fn("Create.project")(function* (rawInput, inp
 	yield* Effect.sync(() => intro(getCreatePrismaIntro(), { output }));
 	const context = yield* atCreateStage(collectCreateContext(input), "collect_context", "unexpected_error");
 	yield* Ref.set(contextRef, Option.some(context));
-	yield* atCreateStage(verifyPackageManagerEffect(context.prismaSetupContext.packageManager), "install_dependencies", "dependency_install_failed");
+	yield* atCreateStage(verifyPackageManagerEffect(context.prismaSetupContext.packageManager), "validate_input", "package_manager_check_failed");
 	return {
 		input,
 		context,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-prisma",
-  "version": "0.13.1",
+  "version": "0.13.2-pr.111.376.1",
   "private": false,
   "description": "Create Prisma 8 projects with first-party templates and great DX.",
   "homepage": "https://github.com/prisma/create-prisma",
@@ -37,7 +37,7 @@
     "dev": "tsdown --watch",
     "start": "bun run ./dist/cli.mjs",
     "test": "bun run test:unit && bun run test:e2e",
-    "test:unit": "bun test ./tests/dependencies.test.ts ./tests/deploy-with-composer.test.ts ./tests/initialize-git.test.ts ./tests/install.test.ts ./tests/json-output.test.ts ./tests/node-version.test.ts ./tests/setup-prisma.test.ts ./tests/telemetry-client.test.ts ./tests/telemetry.test.ts",
+    "test:unit": "bun test ./tests/dependencies.test.ts ./tests/deploy-with-composer.test.ts ./tests/initialize-git.test.ts ./tests/install.test.ts ./tests/json-output.test.ts ./tests/node-version.test.ts ./tests/package-manager-error-code.test.ts ./tests/setup-prisma.test.ts ./tests/telemetry-client.test.ts ./tests/telemetry.test.ts",
     "test:e2e": "bun test --timeout 180000 ./tests/e2e/create-prisma.e2e.test.ts",
     "check": "bun run format:check && bun run lint",
     "lint": "oxlint . --deny-warnings",