@prisma/cli 3.0.0-beta.3 → 3.0.0-beta.30

package/dist/controllers/init.js

@@ -0,0 +1,753 @@
+import { detectPackageManagerSync } from "../lib/agent/package-manager.js";
+import { resolvePrismaCliPackageCommandFormatterSync } from "../lib/agent/cli-command.js";
+import { CliError, usageError } from "../shell/errors.js";
+import { canPrompt } from "../shell/runtime.js";
+import { confirmPrompt, isPromptCancelError, selectPrompt, textPrompt } from "../shell/prompt.js";
+import { readLocalResolutionPin } from "../lib/project/local-pin.js";
+import { readBunPackageEntrypoint, readBunPackageJson } from "../lib/app/bun-project.js";
+import { maybePromptForAgentSetup } from "./agent-setup.js";
+import { runProjectLink } from "./project.js";
+import { detectDeployFramework } from "./app.js";
+import { execa } from "execa";
+import path from "node:path";
+import { readFile, rm, writeFile } from "node:fs/promises";
+import { COMPUTE_CONFIG_FILENAME, COMPUTE_CONFIG_JSON_FILENAME, COMPUTE_REGIONS, FRAMEWORKS, defaultHttpPortForBuildType, findComputeConfigCandidates, findComputeConfigDir, frameworkByKey, frameworkFromAlias, normalizeComputeConfig, serializeComputeConfig, serializeComputeConfigJson } from "@prisma/compute-sdk/config";
+//#region src/controllers/init.ts
+async function runInit(context, flags) {
+	const cwd = context.runtime.cwd;
+	const signal = context.runtime.signal;
+	const formatCommand = resolvePrismaCliPackageCommandFormatterSync(cwd);
+	const format = parseInitFormat(flags.format, formatCommand);
+	if (format.value === "json" && flags.install === true) throw usageError("--install does not apply to the JSON config format", `${COMPUTE_CONFIG_JSON_FILENAME} is a dependency-free static config; the ${COMPUTE_SDK_PACKAGE} devDependency exists only for ${COMPUTE_CONFIG_FILENAME} editor types.`, "Drop --install, or use the TypeScript format.", [formatCommand([
+		"init",
+		"--format",
+		"json"
+	])], "app");
+	const existingConfig = await findExistingComputeConfig(cwd, signal);
+	if (existingConfig) {
+		const solePath = existingConfig.candidates.length === 1 ? existingConfig.candidates[0] : void 0;
+		const soleIsJson = solePath !== void 0 && path.extname(solePath) === ".json";
+		if (soleIsJson && format.value === "typescript" && format.explicit) {
+			rejectConversionResolutionFlags(flags, formatCommand);
+			return runInitConversion(context, flags, solePath, formatCommand);
+		}
+		if (solePath && !soleIsJson && format.value === "json") throw initConvertUnsupportedError(solePath);
+		throw initConfigExistsError(existingConfig.candidates[0] ?? existingConfig.directory);
+	}
+	const region = parseInitRegion(flags.region, formatCommand);
+	let framework = await resolveInitFramework(context, flags, formatCommand);
+	const name = await resolveInitAppName(cwd, flags.name, signal, formatCommand);
+	let httpPort = parseInitHttpPort(flags.httpPort, formatCommand) ?? {
+		value: defaultHttpPortForBuildType(frameworkByKey(framework.key).buildType),
+		source: "framework default"
+	};
+	const adjusted = await maybeAdjustSettings(context, framework, httpPort, { portExplicit: flags.httpPort !== void 0 });
+	framework = adjusted.framework;
+	httpPort = adjusted.httpPort;
+	if (format.value === "json" && framework.key === "custom") throw usageError("Custom framework requires the TypeScript config format", "The custom framework needs build.outputDirectory and build.entrypoint, which init does not collect; the TypeScript format includes a commented build stub to complete, and strict JSON cannot carry it.", `Rerun without --format json and fill in the build stub, or write ${COMPUTE_CONFIG_JSON_FILENAME} by hand with a build object.`, [formatCommand([
+		"init",
+		"--framework",
+		"custom"
+	])], "app");
+	const entry = await resolveInitEntry(cwd, framework, flags.entry, signal);
+	const settings = [
+		{
+			key: "app",
+			value: name.value,
+			source: name.source
+		},
+		{
+			key: "framework",
+			value: framework.displayName,
+			source: framework.source
+		},
+		...entry ? [{
+			key: "entry",
+			value: entry.value,
+			source: entry.source
+		}] : [],
+		{
+			key: "http port",
+			value: String(httpPort.value),
+			source: httpPort.source
+		},
+		...region ? [{
+			key: "region",
+			value: region,
+			source: "flag"
+		}] : []
+	];
+	renderInitSettingsPreview(context, settings);
+	const config = { app: {
+		name: name.value,
+		framework: framework.key,
+		httpPort: httpPort.value,
+		...entry ? { entry: entry.value } : {},
+		...region ? { region } : {}
+	} };
+	const configFilename = format.value === "json" ? COMPUTE_CONFIG_JSON_FILENAME : COMPUTE_CONFIG_FILENAME;
+	const configPath = path.join(cwd, configFilename);
+	let source;
+	if (format.value === "json") source = serializeComputeConfigJson(config);
+	else {
+		source = serializeComputeConfig(config);
+		if (framework.key === "custom") source += CUSTOM_BUILD_STUB;
+	}
+	signal.throwIfAborted();
+	try {
+		await writeFile(configPath, source, {
+			encoding: "utf8",
+			flag: "wx"
+		});
+	} catch (error) {
+		if (error.code === "EEXIST") throw initConfigExistsError(configPath);
+		throw error;
+	}
+	const warnings = [];
+	const types = format.value === "json" ? {
+		status: "skipped",
+		package: COMPUTE_SDK_PACKAGE,
+		installCommand: null
+	} : await resolveInitTypes(context, flags, { onWarning: (message) => warnings.push(message) });
+	const link = await resolveInitLink(context, flags, {
+		onWarning: (message) => warnings.push(message),
+		formatCommand
+	});
+	warnings.push(...await maybePromptForAgentSetup(context, cwd));
+	const unlinked = link.status !== "linked" && link.status !== "already-linked";
+	const typesMissing = types.status !== "installed" && types.status !== "already-installed";
+	return {
+		command: "init",
+		result: {
+			configPath: configFilename,
+			format: format.value,
+			converted: false,
+			directory: formatInitDirectory(cwd),
+			app: {
+				name: name.value,
+				framework: framework.key,
+				httpPort: httpPort.value,
+				...entry ? { entry: entry.value } : {},
+				...region ? { region } : {}
+			},
+			settings,
+			types,
+			link
+		},
+		warnings,
+		nextSteps: [
+			...typesMissing && types.installCommand ? [types.installCommand] : [],
+			formatCommand(["app", "deploy"]),
+			...unlinked ? [formatCommand(["project", "link"])] : []
+		]
+	};
+}
+/** Dev dependency that provides editor types for the generated config. */
+const COMPUTE_SDK_PACKAGE = "@prisma/compute-sdk";
+function packageAddCommand(packageManager) {
+	switch (packageManager) {
+		case "pnpm": return [
+			"pnpm",
+			"add",
+			"-D",
+			COMPUTE_SDK_PACKAGE
+		];
+		case "bun": return [
+			"bun",
+			"add",
+			"-d",
+			COMPUTE_SDK_PACKAGE
+		];
+		case "yarn": return [
+			"yarn",
+			"add",
+			"-D",
+			COMPUTE_SDK_PACKAGE
+		];
+		case "npm": return [
+			"npm",
+			"install",
+			"-D",
+			COMPUTE_SDK_PACKAGE
+		];
+	}
+}
+/**
+* Offers to install `@prisma/compute-sdk` as a devDependency so the generated
+* config's typed import resolves in the editor. Deploy resolves the import
+* without a local install, so every outcome short of success is a hint, never
+* a failure.
+*/
+async function resolveInitTypes(context, flags, hooks) {
+	const cwd = context.runtime.cwd;
+	let packageJson;
+	try {
+		packageJson = await readBunPackageJson(cwd, context.runtime.signal);
+	} catch (error) {
+		if (context.runtime.signal.aborted) throw error;
+		hooks.onWarning(`Skipped the ${COMPUTE_SDK_PACKAGE} types install: package.json could not be read (${error instanceof Error ? error.message.split("\n")[0] : String(error)}).`);
+		return {
+			status: "skipped",
+			package: COMPUTE_SDK_PACKAGE,
+			installCommand: null
+		};
+	}
+	if (hasComputeSdkDependency(packageJson)) return {
+		status: "already-installed",
+		package: COMPUTE_SDK_PACKAGE,
+		installCommand: null
+	};
+	const installCommand = packageAddCommand(detectPackageManagerSync(cwd) ?? "npm");
+	const installCommandText = installCommand.join(" ");
+	const state = (status) => ({
+		status,
+		package: COMPUTE_SDK_PACKAGE,
+		installCommand: installCommandText
+	});
+	if (!packageJson) return state("skipped");
+	if (flags.install === false) return state("skipped");
+	let shouldInstall = flags.install === true;
+	if (!shouldInstall) {
+		if (!canPrompt(context) || context.flags.yes) return state("skipped");
+		try {
+			shouldInstall = await confirmPrompt({
+				input: context.runtime.stdin,
+				output: context.output.stderr,
+				signal: context.runtime.signal,
+				message: `Install ${COMPUTE_SDK_PACKAGE} for config types? (${installCommandText})`,
+				initialValue: true
+			});
+		} catch (error) {
+			if (isPromptCancelError(error)) return state("declined");
+			throw error;
+		}
+		if (!shouldInstall) return state("declined");
+	}
+	const command = resolveInitInstallCommandOverride(context) ?? installCommand;
+	if (!context.flags.quiet && !context.flags.json) context.output.stderr.write(`Installing ${COMPUTE_SDK_PACKAGE}...\n`);
+	try {
+		const [executable, ...args] = command;
+		await execa(executable, args, {
+			cwd,
+			env: context.runtime.env,
+			cancelSignal: context.runtime.signal,
+			stdin: "ignore"
+		});
+		return state("installed");
+	} catch (error) {
+		if (context.runtime.signal.aborted) throw error;
+		const detail = error instanceof Error ? error.message.split("\n")[0] : String(error);
+		hooks.onWarning(`Installing ${COMPUTE_SDK_PACKAGE} failed: ${detail}. Install it later with ${installCommandText}.`);
+		return state("failed");
+	}
+}
+function hasComputeSdkDependency(packageJson) {
+	for (const group of [packageJson?.dependencies, packageJson?.devDependencies]) if (group && typeof group === "object" && COMPUTE_SDK_PACKAGE in group) return true;
+	return false;
+}
+/** Test hook: JSON array command that replaces the real package-manager install. */
+function resolveInitInstallCommandOverride(context) {
+	const raw = context.runtime.env.PRISMA_CLI_INIT_INSTALL_COMMAND;
+	if (!raw) return null;
+	try {
+		const parsed = JSON.parse(raw);
+		return Array.isArray(parsed) && parsed.every((p) => typeof p === "string") ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+const CUSTOM_BUILD_STUB = `
+// framework "custom" deploys a prebuilt artifact. Add its build settings:
+// build: {
+//   command: "npm run build",
+//   outputDirectory: "dist",
+//   entrypoint: "server.js",
+// },
+`;
+/**
+* Nearest existing compute config, searching from `cwd` up to the source
+* root. Init routes on this: refuse, convert, or proceed fresh.
+*/
+async function findExistingComputeConfig(cwd, signal) {
+	const configDir = await findComputeConfigDir(cwd, signal);
+	if (!configDir) return null;
+	return {
+		directory: configDir,
+		candidates: await findComputeConfigCandidates(configDir, signal)
+	};
+}
+function parseInitFormat(value, formatCommand) {
+	if (value === void 0) return {
+		value: "typescript",
+		explicit: false
+	};
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "ts" || normalized === "typescript") return {
+		value: "typescript",
+		explicit: true
+	};
+	if (normalized === "json") return {
+		value: "json",
+		explicit: true
+	};
+	throw usageError("Unknown config format", `"${value}" is not a supported config format.`, "Pass --format ts or --format json.", [formatCommand([
+		"init",
+		"--format",
+		"json"
+	])], "app");
+}
+/**
+* Conversion transports the existing config's values; it never re-resolves
+* settings. Refusing resolution flags beats silently ignoring them.
+*/
+function rejectConversionResolutionFlags(flags, formatCommand) {
+	const passed = [
+		flags.framework !== void 0 ? "--framework" : null,
+		flags.entry !== void 0 ? "--entry" : null,
+		flags.httpPort !== void 0 ? "--http-port" : null,
+		flags.name !== void 0 ? "--name" : null,
+		flags.region !== void 0 ? "--region" : null
+	].filter((flag) => flag !== null);
+	if (passed.length === 0) return;
+	throw usageError(`${passed.join(", ")} ${passed.length === 1 ? "does" : "do"} not apply when converting an existing config`, `--format ts with an existing ${COMPUTE_CONFIG_JSON_FILENAME} converts it as-is; settings are transported, never re-resolved.`, `Convert first, then edit ${COMPUTE_CONFIG_FILENAME} directly.`, [formatCommand([
+		"init",
+		"--format",
+		"ts"
+	])], "app");
+}
+function initConvertIncompleteError(jsonConfigPath, tsConfigPath) {
+	return new CliError({
+		code: "INIT_CONVERT_INCOMPLETE",
+		domain: "app",
+		summary: "Conversion left two config files behind",
+		why: `${path.basename(tsConfigPath)} was written but ${path.basename(jsonConfigPath)} could not be deleted, and rolling back the write also failed. Commands refuse to load a directory with two config files.`,
+		fix: `Delete one file by hand: keep ${path.basename(tsConfigPath)} to finish the conversion, or keep ${path.basename(jsonConfigPath)} to undo it.`,
+		exitCode: 1,
+		nextSteps: [],
+		meta: {
+			jsonConfigPath,
+			tsConfigPath
+		}
+	});
+}
+function initConvertUnsupportedError(existingPath) {
+	return new CliError({
+		code: "INIT_CONVERT_UNSUPPORTED",
+		domain: "app",
+		summary: "TypeScript configs do not convert to JSON",
+		why: `${existingPath} may contain imports, expressions, or comments that the static ${COMPUTE_CONFIG_JSON_FILENAME} format cannot express, so an automatic conversion would be lossy.`,
+		fix: `If the config is fully static, rewrite it by hand as ${COMPUTE_CONFIG_JSON_FILENAME} and delete ${path.basename(existingPath)}.`,
+		exitCode: 1,
+		nextSteps: [],
+		meta: { existingConfigPath: existingPath }
+	});
+}
+/**
+* The graduation path: an explicit `--format ts` with an existing
+* `prisma.compute.json` rewrites the same config as `prisma.compute.ts` and
+* deletes the JSON file, so a static config can grow into a programmatic one.
+* The values are transported, never re-resolved.
+*/
+async function runInitConversion(context, flags, jsonConfigPath, formatCommand) {
+	const cwd = context.runtime.cwd;
+	const signal = context.runtime.signal;
+	let parsed;
+	try {
+		parsed = JSON.parse(await readFile(jsonConfigPath, "utf8"));
+	} catch (error) {
+		if (signal.aborted) throw error;
+		throw initConvertInvalidError(jsonConfigPath, [error instanceof Error ? error.message.split("\n")[0] : String(error)]);
+	}
+	const config = stripJsonSchemaKey(parsed);
+	const normalized = normalizeComputeConfig(config, jsonConfigPath);
+	if (normalized.isErr()) throw initConvertInvalidError(jsonConfigPath, normalized.error.issues);
+	const loaded = normalized.value;
+	const tsConfigPath = path.join(loaded.configDir, COMPUTE_CONFIG_FILENAME);
+	const source = serializeComputeConfig(config);
+	signal.throwIfAborted();
+	try {
+		await writeFile(tsConfigPath, source, {
+			encoding: "utf8",
+			flag: "wx"
+		});
+	} catch (error) {
+		if (error.code === "EEXIST") throw initConfigExistsError(tsConfigPath);
+		throw error;
+	}
+	try {
+		await rm(jsonConfigPath);
+	} catch (error) {
+		try {
+			await rm(tsConfigPath, { force: true });
+		} catch {
+			throw initConvertIncompleteError(jsonConfigPath, tsConfigPath);
+		}
+		throw error;
+	}
+	const settings = conversionSettings(loaded);
+	renderInitSettingsPreview(context, settings);
+	const warnings = [];
+	const stepContext = withRuntimeCwd(context, loaded.configDir);
+	const types = await resolveInitTypes(stepContext, flags, { onWarning: (message) => warnings.push(message) });
+	const link = await resolveInitLink(stepContext, flags, {
+		onWarning: (message) => warnings.push(message),
+		formatCommand
+	});
+	warnings.push(...await maybePromptForAgentSetup(stepContext, loaded.configDir));
+	const unlinked = link.status !== "already-linked" && link.status !== "linked";
+	const typesMissing = types.status !== "installed" && types.status !== "already-installed";
+	return {
+		command: "init",
+		result: {
+			configPath: path.relative(cwd, tsConfigPath) || COMPUTE_CONFIG_FILENAME,
+			format: "typescript",
+			converted: true,
+			directory: formatInitDirectory(loaded.configDir),
+			app: conversionApp(loaded),
+			settings,
+			types,
+			link
+		},
+		warnings,
+		nextSteps: [
+			...typesMissing && types.installCommand ? [types.installCommand] : [],
+			formatCommand(["app", "deploy"]),
+			...unlinked ? [formatCommand(["project", "link"])] : []
+		]
+	};
+}
+/** The same command context, acting from `cwd` instead of the invocation directory. */
+function withRuntimeCwd(context, cwd) {
+	if (path.resolve(context.runtime.cwd) === path.resolve(cwd)) return context;
+	return {
+		...context,
+		runtime: {
+			...context.runtime,
+			cwd
+		}
+	};
+}
+function stripJsonSchemaKey(parsed) {
+	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return parsed;
+	const { $schema: _schema, ...config } = parsed;
+	return config;
+}
+function initConvertInvalidError(jsonConfigPath, issues) {
+	return new CliError({
+		code: "COMPUTE_CONFIG_INVALID",
+		domain: "app",
+		summary: `Invalid ${path.basename(jsonConfigPath)}`,
+		why: issues.join(" "),
+		fix: `Fix ${path.basename(jsonConfigPath)} and rerun the conversion.`,
+		where: jsonConfigPath,
+		meta: {
+			configPath: jsonConfigPath,
+			issues
+		},
+		exitCode: 2,
+		nextSteps: []
+	});
+}
+/** Preview rows for a conversion; every value is sourced from the JSON file. */
+function conversionSettings(loaded) {
+	const target = loaded.kind === "single" ? loaded.targets[0] : void 0;
+	if (!target) return [];
+	const source = COMPUTE_CONFIG_JSON_FILENAME;
+	return [
+		...target.name ? [{
+			key: "app",
+			value: target.name,
+			source
+		}] : [],
+		...target.framework ? [{
+			key: "framework",
+			value: frameworkByKey(target.framework).displayName,
+			source
+		}] : [],
+		...target.entry ? [{
+			key: "entry",
+			value: target.entry,
+			source
+		}] : [],
+		...target.httpPort !== null ? [{
+			key: "http port",
+			value: String(target.httpPort),
+			source
+		}] : [],
+		...target.region ? [{
+			key: "region",
+			value: target.region,
+			source
+		}] : []
+	];
+}
+/**
+* App identity for the conversion result. Configs written by init pin all of
+* name, framework, and httpPort; hand-written configs that omit any of them
+* (or define multiple apps) report null instead of a partial identity.
+*/
+function conversionApp(loaded) {
+	const target = loaded.kind === "single" ? loaded.targets[0] : void 0;
+	if (!target?.name || !target.framework || target.httpPort === null) return null;
+	return {
+		name: target.name,
+		framework: target.framework,
+		httpPort: target.httpPort,
+		...target.entry ? { entry: target.entry } : {},
+		...target.region ? { region: target.region } : {}
+	};
+}
+function initConfigExistsError(existingPath) {
+	return new CliError({
+		code: "INIT_CONFIG_EXISTS",
+		domain: "app",
+		summary: "A compute config already exists",
+		why: `${existingPath} already defines this repository's compute config, and init never overwrites or merges.`,
+		fix: "Edit the existing config instead, or delete it first if you want init to regenerate it.",
+		exitCode: 1,
+		nextSteps: [],
+		meta: { existingConfigPath: existingPath }
+	});
+}
+async function resolveInitFramework(context, flags, formatCommand) {
+	if (flags.framework) {
+		const framework = frameworkFromAlias(flags.framework.trim());
+		if (!framework) throw usageError("Unknown framework", `"${flags.framework}" is not a supported framework.`, `Pass one of: ${FRAMEWORKS.map((candidate) => candidate.key).join(", ")}.`, [formatCommand([
+			"init",
+			"--framework",
+			"hono"
+		])], "app");
+		return {
+			key: framework.key,
+			displayName: framework.displayName,
+			source: "flag"
+		};
+	}
+	const detected = await detectDeployFramework(context.runtime.cwd, context.runtime.signal);
+	if (detected) return {
+		key: detected.key,
+		displayName: detected.displayName,
+		source: detected.annotation
+	};
+	if (canPrompt(context) && !context.flags.yes) {
+		const key = await selectPrompt({
+			input: context.runtime.stdin,
+			output: context.output.stderr,
+			signal: context.runtime.signal,
+			message: "Which framework does this app use?",
+			choices: FRAMEWORKS.map((framework) => ({
+				label: framework.displayName,
+				value: framework.key
+			}))
+		});
+		return {
+			key,
+			displayName: frameworkByKey(key).displayName,
+			source: "selected"
+		};
+	}
+	throw new CliError({
+		code: "INIT_DETECTION_FAILED",
+		domain: "app",
+		summary: "No supported framework detected",
+		why: "The directory has none of the framework signals init detects from, and no --framework was passed.",
+		fix: `Pass --framework with one of: ${FRAMEWORKS.map((framework) => framework.key).join(", ")}.`,
+		exitCode: 1,
+		nextSteps: FRAMEWORKS.slice(0, 3).map((framework) => formatCommand([
+			"init",
+			"--framework",
+			framework.key
+		])),
+		meta: { frameworks: FRAMEWORKS.map((framework) => framework.key) }
+	});
+}
+async function resolveInitAppName(cwd, explicitName, signal, formatCommand) {
+	const trimmed = explicitName?.trim();
+	if (explicitName !== void 0 && !trimmed) throw usageError("App name required", "--name needs a non-empty value.", "Pass a non-empty app name.", [formatCommand([
+		"init",
+		"--name",
+		"api"
+	])], "app");
+	if (trimmed) return {
+		value: trimmed,
+		source: "flag"
+	};
+	const packageJson = await readBunPackageJson(cwd, signal);
+	const packageName = typeof packageJson?.name === "string" ? packageJson.name.trim() : "";
+	if (packageName) return {
+		value: packageName,
+		source: "package.json"
+	};
+	return {
+		value: path.basename(cwd),
+		source: "directory name"
+	};
+}
+function parseInitHttpPort(value, formatCommand) {
+	if (value === void 0) return;
+	const port = Number(value.trim());
+	if (!Number.isInteger(port) || port < 1 || port > 65535) throw usageError("Invalid HTTP port", "--http-port must be an integer between 1 and 65535.", "Pass a valid port.", [formatCommand([
+		"init",
+		"--http-port",
+		"3000"
+	])], "app");
+	return {
+		value: port,
+		source: "flag"
+	};
+}
+function parseInitRegion(value, formatCommand) {
+	if (value === void 0) return;
+	const trimmed = value.trim();
+	if (COMPUTE_REGIONS.includes(trimmed)) return trimmed;
+	throw usageError("Unknown region", `"${value}" is not a supported Compute region.`, `Pass one of: ${COMPUTE_REGIONS.join(", ")}.`, [formatCommand([
+		"init",
+		"--region",
+		"us-east-1"
+	])], "app");
+}
+async function resolveInitEntry(cwd, resolvedFramework, explicitEntry, signal) {
+	const framework = frameworkByKey(resolvedFramework.key);
+	const trimmed = explicitEntry?.trim();
+	if (!framework.usesEntrypoint) {
+		if (trimmed) throw usageError("--entry is not supported for this framework", `${resolvedFramework.displayName} derives its entrypoint from build output; --entry applies only to frameworks that run a source entrypoint (Bun, Hono).`, "Drop --entry, or pass an entrypoint framework with --framework.", [], "app");
+		return;
+	}
+	if (trimmed) return {
+		value: trimmed,
+		source: "flag"
+	};
+	const packageEntrypoint = readBunPackageEntrypoint(await readBunPackageJson(cwd, signal));
+	if (packageEntrypoint) return {
+		value: packageEntrypoint,
+		source: "package.json"
+	};
+}
+async function maybeAdjustSettings(context, framework, httpPort, options) {
+	if (!canPrompt(context) || context.flags.yes) return {
+		framework,
+		httpPort
+	};
+	if (!await confirmPrompt({
+		input: context.runtime.stdin,
+		output: context.output.stderr,
+		signal: context.runtime.signal,
+		message: `Adjust these settings? (${framework.displayName}, HTTP ${httpPort.value})`,
+		initialValue: false
+	})) return {
+		framework,
+		httpPort
+	};
+	const key = await selectPrompt({
+		input: context.runtime.stdin,
+		output: context.output.stderr,
+		signal: context.runtime.signal,
+		message: "Framework",
+		choices: FRAMEWORKS.map((candidate) => ({
+			label: candidate.key === framework.key ? `${candidate.displayName} (current)` : candidate.displayName,
+			value: candidate.key
+		}))
+	});
+	const nextFramework = key === framework.key ? framework : {
+		key,
+		displayName: frameworkByKey(key).displayName,
+		source: "selected"
+	};
+	const defaultPort = options.portExplicit ? httpPort.value : defaultHttpPortForBuildType(frameworkByKey(key).buildType);
+	const portText = await textPrompt({
+		input: context.runtime.stdin,
+		output: context.output.stderr,
+		signal: context.runtime.signal,
+		message: "HTTP port",
+		placeholder: String(defaultPort),
+		validate: (value) => {
+			if (!value?.trim()) return;
+			const port = Number(value.trim());
+			return Number.isInteger(port) && port >= 1 && port <= 65535 ? void 0 : "Enter a port between 1 and 65535.";
+		}
+	});
+	return {
+		framework: nextFramework,
+		httpPort: portText.trim() ? {
+			value: Number(portText.trim()),
+			source: "selected"
+		} : {
+			value: defaultPort,
+			source: options.portExplicit ? httpPort.source : "framework default"
+		}
+	};
+}
+function renderInitSettingsPreview(context, settings) {
+	if (context.flags.quiet || context.flags.json) return;
+	const keyWidth = Math.max(...settings.map((row) => row.key.length));
+	const valueWidth = Math.max(...settings.map((row) => row.value.length));
+	const lines = settings.map((row) => `  ${row.key.padEnd(keyWidth)}  ${row.value.padEnd(valueWidth)}  ${context.ui.dim(row.source)}`);
+	context.output.stderr.write(`${lines.join("\n")}\n\n`);
+}
+async function resolveInitLink(context, flags, hooks) {
+	const pin = await readLocalResolutionPin(context.runtime.cwd, context.runtime.signal);
+	if (pin.isOk() && pin.value.kind === "present") return {
+		status: "already-linked",
+		project: null
+	};
+	if (flags.link === false) return {
+		status: "skipped",
+		project: null
+	};
+	const explicitProject = flags.project?.trim();
+	let shouldLink = Boolean(explicitProject) || flags.link === true;
+	if (!shouldLink) {
+		if (!canPrompt(context) || context.flags.yes) return {
+			status: "skipped",
+			project: null
+		};
+		try {
+			shouldLink = await confirmPrompt({
+				input: context.runtime.stdin,
+				output: context.output.stderr,
+				signal: context.runtime.signal,
+				message: "Link this directory to a Prisma Project now?",
+				initialValue: true
+			});
+		} catch (error) {
+			if (isPromptCancelError(error)) return {
+				status: "declined",
+				project: null
+			};
+			throw error;
+		}
+		if (!shouldLink) return {
+			status: "declined",
+			project: null
+		};
+	}
+	try {
+		const linked = await runProjectLink(context, explicitProject || void 0);
+		return {
+			status: "linked",
+			project: {
+				id: linked.result.project.id,
+				name: linked.result.project.name
+			}
+		};
+	} catch (error) {
+		if (error instanceof CliError) {
+			if (isPromptCancelError(error)) return {
+				status: "declined",
+				project: null
+			};
+			hooks.onWarning(`Project link failed: ${error.summary}. Link later with ${hooks.formatCommand(["project", "link"])}.`);
+			return {
+				status: "failed",
+				project: null
+			};
+		}
+		throw error;
+	}
+}
+function formatInitDirectory(cwd) {
+	const basename = path.basename(cwd);
+	return basename ? `./${basename}` : ".";
+}
+//#endregion
+export { runInit };