@prisma/cli 3.0.0-dev.116.1 → 3.0.0-dev.117.1

package/dist/cli2.js

@@ -12,6 +12,7 @@ import { createBranchCommand } from "./commands/branch/index.js";
 import { createBuildCommand } from "./commands/build/index.js";
 import { createDatabaseCommand } from "./commands/database/index.js";
 import { createGitCommand } from "./commands/git/index.js";
+import { createInitCommand } from "./commands/init/index.js";
 import { createProjectCommand } from "./commands/project/index.js";
 import { getCliName, getCliVersion } from "./lib/version.js";
 import { runVersion } from "./controllers/version.js";
@@ -48,6 +49,7 @@ function createProgram(runtime) {
 	program.addOption(new Option("--version", "Print the CLI version and exit."));
 	program.name("prisma").showSuggestionAfterError();
 	program.addCommand(createVersionCommand(runtime));
+	program.addCommand(createInitCommand(runtime));
 	program.addCommand(createAgentCommand(runtime));
 	program.addCommand(createAuthCommand(runtime));
 	program.addCommand(createProjectCommand(runtime));

package/dist/commands/init/index.js

@@ -0,0 +1,32 @@
+import { attachCommandDescriptor } from "../../shell/command-meta.js";
+import { addGlobalFlags } from "../../shell/global-flags.js";
+import { configureRuntimeCommand } from "../../shell/runtime.js";
+import { runCommand } from "../../shell/command-runner.js";
+import { runInit } from "../../controllers/init.js";
+import { renderInit, serializeInit } from "../../presenters/init.js";
+import { Command, Option } from "commander";
+//#region src/commands/init/index.ts
+function createInitCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("init"), runtime), "init");
+	command.addOption(new Option("--framework <framework>", "Framework override; detected when omitted")).addOption(new Option("--entry <path>", "Source entrypoint for entrypoint frameworks (Bun, Hono)")).addOption(new Option("--http-port <port>", "HTTP port the app listens on")).addOption(new Option("--region <region>", "Region used when deploy creates the app")).addOption(new Option("--name <app-name>", "App name")).addOption(new Option("--link", "Link this directory to a Project")).addOption(new Option("--no-link", "Skip the Project link step")).addOption(new Option("--project <id-or-name>", "Project to link this directory to")).addOption(new Option("--install", "Install @prisma/compute-sdk for config types")).addOption(new Option("--no-install", "Skip the types install step"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const flags = options;
+		await runCommand(runtime, "init", options, (context) => runInit(context, {
+			framework: flags.framework,
+			entry: flags.entry,
+			httpPort: flags.httpPort,
+			region: flags.region,
+			name: flags.name,
+			link: flags.link,
+			project: flags.project,
+			install: flags.install
+		}), {
+			renderHuman: (context, descriptor, result) => renderInit(context, descriptor, result),
+			renderJson: (result) => serializeInit(result)
+		});
+	});
+	return command;
+}
+//#endregion
+export { createInitCommand };

package/dist/controllers/app.js

@@ -2528,4 +2528,4 @@ function toOptionalEnvVars(envVars) {
 	return Object.keys(envVars).length > 0 ? envVars : void 0;
 }
 //#endregion
-export { runAppBuild, runAppDeploy, runAppDomainAdd, runAppDomainRemove, runAppDomainRetry, runAppDomainShow, runAppDomainWait, runAppListDeploys, runAppLogs, runAppOpen, runAppPromote, runAppRemove, runAppRollback, runAppRun, runAppShow, runAppShowDeploy };
+export { detectDeployFramework, runAppBuild, runAppDeploy, runAppDomainAdd, runAppDomainRemove, runAppDomainRetry, runAppDomainShow, runAppDomainWait, runAppListDeploys, runAppLogs, runAppOpen, runAppPromote, runAppRemove, runAppRollback, runAppRun, runAppShow, runAppShowDeploy };

package/dist/controllers/init.js

@@ -0,0 +1,491 @@
+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 { runProjectLink } from "./project.js";
+import { detectDeployFramework } from "./app.js";
+import { execa } from "execa";
+import path from "node:path";
+import { writeFile } from "node:fs/promises";
+import { COMPUTE_CONFIG_FILENAME, COMPUTE_REGIONS, FRAMEWORKS, defaultHttpPortForBuildType, findComputeConfigCandidates, findComputeConfigDir, frameworkByKey, frameworkFromAlias, serializeComputeConfig } 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);
+	await requireNoExistingComputeConfig(cwd, signal);
+	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;
+	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 configPath = path.join(cwd, COMPUTE_CONFIG_FILENAME);
+	let 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 = await resolveInitTypes(context, flags, { onWarning: (message) => warnings.push(message) });
+	const link = await resolveInitLink(context, flags, {
+		onWarning: (message) => warnings.push(message),
+		formatCommand
+	});
+	const unlinked = link.status !== "linked" && link.status !== "already-linked";
+	const typesMissing = types.status !== "installed" && types.status !== "already-installed";
+	return {
+		command: "init",
+		result: {
+			configPath: COMPUTE_CONFIG_FILENAME,
+			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",
+// },
+`;
+async function requireNoExistingComputeConfig(cwd, signal) {
+	const configDir = await findComputeConfigDir(cwd, signal);
+	if (!configDir) return;
+	throw initConfigExistsError((await findComputeConfigCandidates(configDir, signal))[0] ?? configDir);
+}
+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 };

package/dist/lib/agent/cli-command.js

@@ -10,8 +10,11 @@ async function resolvePrismaCliPackageCommand(options) {
 function resolvePrismaCliPackageCommandFormatterSync(cwd) {
 	return createPrismaCliPackageCommandFormatter(resolvePackageRunnerSync(cwd));
 }
+function resolvePrismaCliPackageCommandSync(cwd, args) {
+	return resolvePrismaCliPackageCommandFormatterSync(cwd)(args);
+}
 function createPrismaCliPackageCommandFormatter(packageRunner) {
 	return (args) => formatPrismaCliCommand(args, { packageRunner });
 }
 //#endregion
-export { resolvePrismaCliPackageCommand, resolvePrismaCliPackageCommandFormatterSync };
+export { resolvePrismaCliPackageCommand, resolvePrismaCliPackageCommandFormatterSync, resolvePrismaCliPackageCommandSync };

package/dist/lib/agent/package-manager.js

@@ -96,4 +96,4 @@ function isMissingFileError(error) {
 	return code === "ENOENT" || code === "ENOTDIR";
 }
 //#endregion
-export { resolvePackageRunner, resolvePackageRunnerSync, resolveSkillsPackageRunner };
+export { detectPackageManagerSync, resolvePackageRunner, resolvePackageRunnerSync, resolveSkillsPackageRunner };

package/dist/presenters/app.js

@@ -1,3 +1,4 @@
+import { resolvePrismaCliPackageCommandSync } from "../lib/agent/cli-command.js";
 import { renderVerboseBlock } from "../shell/ui.js";
 import { renderDeployOutputRows } from "../lib/app/deploy-output.js";
 import { formatDomainFailureFix } from "../lib/app/domain-guidance.js";
@@ -38,17 +39,31 @@ function renderAppDeploy(context, descriptor, result, options) {
 		],
 		...renderBranchDatabaseDeploySummary(context, result),
 		"",
-		...renderDeployOutputRows(context.ui, [...result.promoted ? [] : [{
-			label: "Promote",
-			value: `prisma-cli app promote ${result.deployment.id}`
-		}], {
-			label: "Logs",
-			value: logsCommand
-		}]),
+		...renderDeployOutputRows(context.ui, [
+			...result.promoted ? [] : [{
+				label: "Promote",
+				value: `prisma-cli app promote ${result.deployment.id}`
+			}],
+			{
+				label: "Logs",
+				value: logsCommand
+			},
+			...deployUsedComputeConfig(result) ? [] : [{
+				label: "Config",
+				value: resolvePrismaCliPackageCommandSync(context.runtime.cwd, ["init"])
+			}]
+		]),
 		...renderDeployResolvedContextBlock(context, result),
 		...renderDeploySettingsBlock(context, result)
 	];
 }
+function deployUsedComputeConfig(result) {
+	return result.deploySettings.config.path !== null || [
+		result.deploySettings.framework.source,
+		result.deploySettings.buildCommand.source,
+		result.deploySettings.outputDirectory.source
+	].some((source) => source?.includes("prisma.compute"));
+}
 function isAppDeployAllResult(result) {
 	return "deployments" in result;
 }

package/dist/presenters/init.js

@@ -0,0 +1,29 @@
+import { resolvePrismaCliPackageCommandFormatterSync } from "../lib/agent/cli-command.js";
+import { renderNextSteps, renderSummaryLine } from "../shell/ui.js";
+//#region src/presenters/init.ts
+function renderInit(context, _descriptor, result) {
+	const ui = context.ui;
+	const formatCommand = resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd);
+	const lines = [renderSummaryLine(ui, "success", `Wrote ${result.configPath}`)];
+	if (result.types.status === "installed") lines.push(renderSummaryLine(ui, "success", `Installed ${result.types.package} (config types)`));
+	else if ((result.types.status === "skipped" || result.types.status === "declined") && result.types.installCommand) lines.push(`  ${ui.dim(`For editor types: ${result.types.installCommand}`)}`);
+	switch (result.link.status) {
+		case "linked":
+			lines.push(renderSummaryLine(ui, "success", `Linked "${result.directory}" to Project "${result.link.project?.name ?? ""}"`));
+			break;
+		case "already-linked": break;
+		case "skipped":
+		case "declined":
+			lines.push(`  ${ui.dim(`Not linked to a Project yet; link with ${formatCommand(["project", "link"])}.`)}`);
+			break;
+		case "failed": break;
+	}
+	const linked = result.link.status === "linked" || result.link.status === "already-linked";
+	lines.push(...renderNextSteps([formatCommand(["app", "deploy"]), ...linked ? [] : [formatCommand(["project", "link"])]]));
+	return lines;
+}
+function serializeInit(result) {
+	return result;
+}
+//#endregion
+export { renderInit, serializeInit };

package/dist/shell/command-meta.js

@@ -20,6 +20,22 @@ const DESCRIPTORS = [
 		description: "Show CLI build and environment",
 		examples: ["prisma-cli version", "prisma-cli version --json"]
 	},
+	{
+		id: "init",
+		path: ["prisma", "init"],
+		description: "Write a committed prisma.compute.ts for this app",
+		examples: (runtime) => agentCommandExamples(runtime, [
+			["init"],
+			[
+				"init",
+				"--framework",
+				"hono",
+				"--entry",
+				"src/index.ts"
+			],
+			["init", "--no-link"]
+		])
+	},
 	{
 		id: "agent",
 		path: ["prisma", "agent"],

package/dist/shell/errors.js

@@ -44,6 +44,12 @@ function usageError(summary, why, fix, nextSteps = [], domain = "cli") {
 		nextSteps
 	});
 }
+function isUsageError(error, summary) {
+	return isErrorRecord(error) && error.code === "USAGE_ERROR" && (summary === void 0 || error.summary === summary);
+}
+function isErrorRecord(error) {
+	return typeof error === "object" && error !== null;
+}
 function authRequiredError(nextSteps = ["prisma-cli auth login"], options = {}) {
 	return new CliError({
 		code: "AUTH_REQUIRED",
@@ -131,4 +137,4 @@ function featureUnavailableError(summary, why, fix, nextSteps = [], domain = "cl
 	});
 }
 //#endregion
-export { CliError, authConfigInvalidError, authRequiredError, commandCanceledError, featureUnavailableError, usageError, workspaceAmbiguousError, workspaceNotAuthenticatedError, workspaceRequiredError, workspaceSwitchUnavailableError };
+export { CliError, authConfigInvalidError, authRequiredError, commandCanceledError, featureUnavailableError, isUsageError, usageError, workspaceAmbiguousError, workspaceNotAuthenticatedError, workspaceRequiredError, workspaceSwitchUnavailableError };

package/dist/shell/prompt.js

@@ -1,4 +1,4 @@
-import { usageError } from "./errors.js";
+import { isUsageError, usageError } from "./errors.js";
 import { confirm, isCancel, select, text } from "@clack/prompts";
 //#region src/shell/prompt.ts
 const PROMPT_CANCELED_SUMMARY = "Interactive prompt canceled";
@@ -40,6 +40,9 @@ async function confirmPrompt(options) {
 	if (isCancel(response)) throw usageError(PROMPT_CANCELED_SUMMARY, "The command was canceled before a confirmation was made.", "Re-run the command and choose an option to continue.");
 	return response;
 }
+function isPromptCancelError(error) {
+	return isUsageError(error, PROMPT_CANCELED_SUMMARY);
+}
 function disposePromptState(_input) {}
 //#endregion
-export { confirmPrompt, disposePromptState, selectPrompt, textPrompt };
+export { confirmPrompt, disposePromptState, isPromptCancelError, selectPrompt, textPrompt };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-dev.116.1",
+  "version": "3.0.0-dev.117.1",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {