@prisma/cli 8.0.0-rc.1 → 8.0.0-rc.10-dev.80

package/dist/controllers/init.js

@@ -1,814 +0,0 @@
-import { detectPackageManagerSync } from "../lib/agent/package-manager.js";
-import { resolvePrismaCliPackageCommandFormatterSync } from "../lib/agent/cli-command.js";
-import { CliError, usageError } from "../errors.js";
-import { canPrompt } from "../shell/runtime.js";
-import { confirmPrompt, isPromptCancelError, selectPrompt, textPrompt } from "../shell/prompt.js";
-import { readBunPackageEntrypoint, readBunPackageJson } from "../lib/app/bun-project.js";
-import { readLocalResolutionPin } from "../lib/project/local-pin.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);
-	rejectInstallFlagForJsonFormat(format.value, flags, formatCommand);
-	const route = await routeExistingComputeConfig(cwd, signal, format);
-	if (route.kind === "convert") {
-		rejectConversionResolutionFlags(flags, formatCommand);
-		return runInitConversion(context, flags, route.jsonConfigPath, formatCommand);
-	}
-	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;
-	rejectCustomFrameworkForJsonFormat(format.value, framework, formatCommand);
-	const entry = await resolveInitEntry(cwd, framework, flags.entry, signal);
-	const resolved = {
-		name,
-		framework,
-		entry,
-		httpPort,
-		region
-	};
-	const settings = initSettingRows(resolved);
-	renderInitSettingsPreview(context, settings);
-	const app = initAppConfig(resolved);
-	const configFile = initConfigFile({ app }, format.value, framework.key);
-	const configPath = path.join(cwd, configFile.filename);
-	signal.throwIfAborted();
-	await writeInitConfigFile(configPath, configFile.source);
-	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));
-	return {
-		command: "init",
-		result: {
-			configPath: configFile.filename,
-			format: format.value,
-			converted: false,
-			directory: formatInitDirectory(cwd),
-			app,
-			settings,
-			types,
-			link
-		},
-		warnings,
-		nextSteps: initNextSteps(types, link, formatCommand)
-	};
-}
-function rejectInstallFlagForJsonFormat(format, flags, formatCommand) {
-	if (format !== "json" || flags.install !== true) return;
-	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");
-}
-/**
-* The custom framework needs build.outputDirectory and build.entrypoint,
-* which init does not collect. The TypeScript format carries a commented
-* build stub to fill in; strict JSON cannot hold comments, so refuse here
-* instead of writing a config that deploy would reject.
-*/
-function rejectCustomFrameworkForJsonFormat(format, framework, formatCommand) {
-	if (format !== "json" || framework.key !== "custom") return;
-	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");
-}
-/** Preview rows for a fresh init, one per resolved setting. */
-function initSettingRows(resolved) {
-	const { name, framework, entry, httpPort, region } = resolved;
-	return [
-		{
-			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"
-		}] : []
-	];
-}
-/** App identity written to the config and reported in the result. */
-function initAppConfig(resolved) {
-	const { name, framework, entry, httpPort, region } = resolved;
-	return {
-		name: name.value,
-		framework: framework.key,
-		httpPort: httpPort.value,
-		...entry ? { entry: entry.value } : {},
-		...region ? { region } : {}
-	};
-}
-/** Name and contents of the config file for the chosen format. */
-function initConfigFile(config, format, framework) {
-	if (format === "json") return {
-		filename: COMPUTE_CONFIG_JSON_FILENAME,
-		source: serializeComputeConfigJson(config)
-	};
-	const source = serializeComputeConfig(config);
-	return {
-		filename: COMPUTE_CONFIG_FILENAME,
-		source: framework === "custom" ? source + CUSTOM_BUILD_STUB : source
-	};
-}
-async function writeInitConfigFile(configPath, source) {
-	try {
-		await writeFile(configPath, source, {
-			encoding: "utf8",
-			flag: "wx"
-		});
-	} catch (error) {
-		if (error.code === "EEXIST") throw initConfigExistsError(configPath);
-		throw error;
-	}
-}
-function initNextSteps(types, link, formatCommand) {
-	const typesMissing = types.status !== "installed" && types.status !== "already-installed";
-	const unlinked = link.status !== "linked" && link.status !== "already-linked";
-	return [
-		...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;
-	const read = await readPackageJsonForTypes(context, hooks);
-	if (!read.readable) return {
-		status: "skipped",
-		package: COMPUTE_SDK_PACKAGE,
-		installCommand: null
-	};
-	const packageJson = read.packageJson;
-	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");
-	const decision = await resolveTypesInstallDecision(context, flags, installCommandText);
-	if (decision !== "install") return state(decision);
-	return state(await installComputeSdkTypes(context, installCommand, hooks));
-}
-/**
-* The types install runs after the config is written, so an unreadable
-* package.json (malformed JSON, permissions) must not turn the already
-* successful write into a command failure; it degrades to a skip.
-*/
-async function readPackageJsonForTypes(context, hooks) {
-	try {
-		return {
-			readable: true,
-			packageJson: await readBunPackageJson(context.runtime.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 (${firstErrorLine(error)}).`);
-		return { readable: false };
-	}
-}
-async function resolveTypesInstallDecision(context, flags, installCommandText) {
-	if (flags.install === false) return "skipped";
-	if (flags.install === true) return "install";
-	if (!canPrompt(context) || context.flags.yes) return "skipped";
-	try {
-		return 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
-		}) ? "install" : "declined";
-	} catch (error) {
-		if (isPromptCancelError(error)) return "declined";
-		throw error;
-	}
-}
-async function installComputeSdkTypes(context, installCommand, hooks) {
-	const installCommandText = installCommand.join(" ");
-	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: context.runtime.cwd,
-			env: context.runtime.env,
-			cancelSignal: context.runtime.signal,
-			stdin: "ignore"
-		});
-		return "installed";
-	} catch (error) {
-		if (context.runtime.signal.aborted) throw error;
-		hooks.onWarning(`Installing ${COMPUTE_SDK_PACKAGE} failed: ${firstErrorLine(error)}. Install it later with ${installCommandText}.`);
-		return "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)
-	};
-}
-/**
-* Init's route when a config already exists: convert a sole JSON config that
-* an explicit `--format ts` asked for, or refuse. A directory with no config
-* proceeds fresh.
-*/
-async function routeExistingComputeConfig(cwd, signal, format) {
-	const existingConfig = await findExistingComputeConfig(cwd, signal);
-	if (!existingConfig) return { kind: "fresh" };
-	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) return {
-		kind: "convert",
-		jsonConfigPath: solePath
-	};
-	if (solePath && !soleIsJson && format.value === "json") throw initConvertUnsupportedError(solePath);
-	throw initConfigExistsError(existingConfig.candidates[0] ?? existingConfig.directory);
-}
-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;
-	const { config, loaded } = await readConvertibleJsonConfig(jsonConfigPath, signal);
-	const tsConfigPath = path.join(loaded.configDir, COMPUTE_CONFIG_FILENAME);
-	const source = serializeComputeConfig(config);
-	signal.throwIfAborted();
-	await writeInitConfigFile(tsConfigPath, source);
-	await removeConvertedJsonConfig(jsonConfigPath, tsConfigPath);
-	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));
-	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: initNextSteps(types, link, formatCommand)
-	};
-}
-/**
-* The JSON config a conversion transports: its parsed contents, plus the
-* normalized view the preview and result are built from.
-*/
-async function readConvertibleJsonConfig(jsonConfigPath, signal) {
-	let parsed;
-	try {
-		parsed = JSON.parse(await readFile(jsonConfigPath, "utf8"));
-	} catch (error) {
-		if (signal.aborted) throw error;
-		throw initConvertInvalidError(jsonConfigPath, [firstErrorLine(error)]);
-	}
-	const config = stripJsonSchemaKey(parsed);
-	const normalized = normalizeComputeConfig(config, jsonConfigPath);
-	if (normalized.isErr()) throw initConvertInvalidError(jsonConfigPath, normalized.error.issues);
-	return {
-		config,
-		loaded: normalized.value
-	};
-}
-async function removeConvertedJsonConfig(jsonConfigPath, tsConfigPath) {
-	try {
-		await rm(jsonConfigPath);
-	} catch (error) {
-		try {
-			await rm(tsConfigPath, { force: true });
-		} catch {
-			throw initConvertIncompleteError(jsonConfigPath, tsConfigPath);
-		}
-		throw error;
-	}
-}
-/** 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
-	};
-	const explicitProject = flags.project?.trim();
-	const decision = await resolveProjectLinkDecision(context, flags, explicitProject);
-	if (decision !== "link") return {
-		status: decision,
-		project: null
-	};
-	return attemptProjectLink(context, explicitProject, hooks);
-}
-async function resolveProjectLinkDecision(context, flags, explicitProject) {
-	if (flags.link === false) return "skipped";
-	if (explicitProject || flags.link === true) return "link";
-	if (!canPrompt(context) || context.flags.yes) return "skipped";
-	try {
-		return 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
-		}) ? "link" : "declined";
-	} catch (error) {
-		if (isPromptCancelError(error)) return "declined";
-		throw error;
-	}
-}
-async function attemptProjectLink(context, explicitProject, hooks) {
-	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 firstErrorLine(error) {
-	return error instanceof Error ? error.message.split("\n")[0] : String(error);
-}
-function formatInitDirectory(cwd) {
-	const basename = path.basename(cwd);
-	return basename ? `./${basename}` : ".";
-}
-//#endregion
-export { runInit };