@prisma/cli 2.20.0 → 3.0.0-alpha.0

package/dist/controllers/auth.js

@@ -0,0 +1,107 @@
+import { authRequiredError, usageError } from "../shell/errors.js";
+import { canPrompt } from "../shell/runtime.js";
+import { createSelectPromptPort } from "./select-prompt-port.js";
+import { createAuthUseCases } from "../use-cases/auth.js";
+import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
+import { performLogin, performLogout, readAuthState } from "../lib/auth/auth-ops.js";
+//#region src/controllers/auth.ts
+function isRealMode(context) {
+	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
+}
+async function runAuthLogin(context, options) {
+	let result;
+	if (isRealMode(context)) {
+		await performLogin(context.runtime.env);
+		result = await readAuthState(context.runtime.env);
+	} else result = await loginWithSelectionFlow(context, createAuthUseCases(createCliUseCaseGateways(context)), options);
+	return createAuthSuccess("auth.login", result, ["prisma auth whoami", "prisma project list"]);
+}
+async function runAuthLogout(context) {
+	let result;
+	if (isRealMode(context)) {
+		await performLogout(context.runtime.env);
+		result = await readAuthState(context.runtime.env);
+	} else result = await createAuthUseCases(createCliUseCaseGateways(context)).logout();
+	return createAuthSuccess("auth.logout", result, ["prisma auth login"]);
+}
+async function runAuthWhoAmI(context) {
+	let result;
+	if (isRealMode(context)) result = await readAuthState(context.runtime.env);
+	else result = await createAuthUseCases(createCliUseCaseGateways(context)).whoami();
+	return createAuthSuccess("auth.whoami", result, result.authenticated ? [] : ["prisma auth login"]);
+}
+async function requireAuthenticatedAuthState(context) {
+	if (isRealMode(context)) {
+		const current = await readAuthState(context.runtime.env);
+		if (current.authenticated) return current;
+		if (!canPrompt(context)) throw authRequiredError();
+		await performLogin(context.runtime.env);
+		return readAuthState(context.runtime.env);
+	}
+	const useCases = createAuthUseCases(createCliUseCaseGateways(context));
+	const current = await useCases.whoami();
+	if (current.authenticated) return current;
+	if (!canPrompt(context)) throw authRequiredError();
+	return loginWithSelectionFlow(context, useCases, {});
+}
+async function loginWithSelectionFlow(context, useCases, options) {
+	const selection = await resolveLoginSelection(useCases, canPrompt(context) ? createSelectPromptPort(context) : null, options);
+	return useCases.login(selection);
+}
+async function resolveLoginSelection(useCases, prompt, options) {
+	const provider = options.provider ? (await useCases.resolveProvider(options.provider)).id : (await selectProvider(useCases, prompt)).id;
+	const user = options.user ? await useCases.resolveUserForProvider(provider, options.user) : await selectUser(useCases, prompt, provider);
+	const workspace = options.workspace ? await useCases.resolveWorkspaceForUser(user.id, options.workspace) : await selectWorkspace(useCases, prompt, user.id);
+	return {
+		provider,
+		userId: user.id,
+		workspaceId: workspace.id
+	};
+}
+async function selectProvider(useCases, prompt) {
+	if (!prompt) throw nonInteractiveLoginError("Re-run prisma auth login in a TTY, or provide --provider and --user, and --workspace when required.");
+	const providers = await useCases.listProviders();
+	return prompt.select({
+		message: "Select a provider",
+		choices: providers.map((provider) => ({
+			label: provider.name,
+			value: provider
+		}))
+	});
+}
+async function selectUser(useCases, prompt, provider) {
+	const users = await useCases.listUsersForProvider(provider);
+	if (!prompt) throw nonInteractiveLoginError("Re-run prisma auth login in a TTY, or provide --provider and --user, and --workspace when required.");
+	return prompt.select({
+		message: "Select a user",
+		choices: users.map((user) => ({
+			label: `${user.name} <${user.email}>`,
+			value: user
+		}))
+	});
+}
+async function selectWorkspace(useCases, prompt, userId) {
+	const workspaces = await useCases.listWorkspacesForUser(userId);
+	if (workspaces.length === 1) return workspaces[0];
+	if (!prompt) throw usageError("Login requires explicit selectors in non-interactive mode", "The selected mock user belongs to more than one workspace and the shell cannot prompt in the current mode.", "Re-run prisma auth login in a TTY, or provide --workspace.", ["prisma auth login"], "auth");
+	return prompt.select({
+		message: "Select a workspace",
+		choices: workspaces.map((workspace) => ({
+			label: `${workspace.name} (${workspace.id})`,
+			value: workspace
+		}))
+	});
+}
+function nonInteractiveLoginError(fix) {
+	return usageError("Login requires explicit selectors in non-interactive mode", "The fixture mode cannot prompt in the current mode.", fix, ["prisma auth login"], "auth");
+}
+function createAuthSuccess(command, result, nextSteps) {
+	return {
+		command,
+		result,
+		warnings: [],
+		nextSteps
+	};
+}
+//#endregion
+export { requireAuthenticatedAuthState, runAuthLogin, runAuthLogout, runAuthWhoAmI };

package/dist/controllers/branch.js

@@ -0,0 +1,73 @@
+import { featureUnavailableError, usageError } from "../shell/errors.js";
+import { canPrompt } from "../shell/runtime.js";
+import { createSelectPromptPort } from "./select-prompt-port.js";
+import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
+import { createBranchUseCases } from "../use-cases/branch.js";
+//#region src/controllers/branch.ts
+const PREVIEW_BRANCH_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function isRealMode(context) {
+	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
+}
+async function runBranchList(context) {
+	if (isRealMode(context)) throw branchCommandsUnavailableError();
+	return {
+		command: "branch.list",
+		result: await createBranchUseCases(createCliUseCaseGateways(context)).list(),
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runBranchShow(context) {
+	if (isRealMode(context)) throw branchCommandsUnavailableError();
+	const result = await createBranchUseCases(createCliUseCaseGateways(context)).show();
+	return {
+		command: "branch.show",
+		result,
+		warnings: [],
+		nextSteps: result.branch.kind === "preview" && !result.branch.remoteState ? ["prisma app deploy"] : []
+	};
+}
+async function runBranchUse(context, branchName) {
+	if (isRealMode(context)) throw branchCommandsUnavailableError();
+	const useCases = createBranchUseCases(createCliUseCaseGateways(context));
+	const resolvedBranchName = await resolveBranchNameForUse(context, useCases, branchName);
+	validateBranchName(resolvedBranchName);
+	const result = await useCases.use(resolvedBranchName);
+	return {
+		command: "branch.use",
+		result,
+		warnings: result.branch.kind === "production" ? ["Production is protected and durable. Use with care."] : [],
+		nextSteps: result.branch.kind === "preview" && !result.branch.remoteState ? ["prisma branch show", "prisma app deploy"] : ["prisma branch show"]
+	};
+}
+async function resolveBranchNameForUse(context, useCases, branchName) {
+	if (branchName) return branchName;
+	if (!canPrompt(context)) throw branchSelectionRequiredError();
+	const result = await useCases.list();
+	return createSelectPromptPort(context).select({
+		message: "Select a branch",
+		choices: result.branches.map((branch) => ({
+			label: renderBranchChoiceLabel(branch),
+			value: branch.name
+		}))
+	});
+}
+function renderBranchChoiceLabel(branch) {
+	const markers = [];
+	if (branch.active) markers.push("active");
+	if (!branch.remoteState) markers.push("not created yet");
+	return markers.length > 0 ? `${branch.name} (${markers.join(", ")})` : branch.name;
+}
+function validateBranchName(branchName) {
+	if (branchName === "production") return;
+	if (PREVIEW_BRANCH_PATTERN.test(branchName)) return;
+	throw usageError("Branch name must use the documented form", "Branch names must be production or a lowercase preview slug such as preview or feat-auth.", "Use production or a lowercase preview branch name with letters, numbers, and hyphens.", ["prisma branch list"], "branch");
+}
+function branchSelectionRequiredError() {
+	return usageError("Branch use requires a target in non-interactive mode", "This command cannot prompt for branch selection in the current mode.", "Re-run prisma branch use in a TTY, or pass a branch name explicitly.", ["prisma branch list"], "branch");
+}
+function branchCommandsUnavailableError() {
+	return featureUnavailableError("Branch commands are not available in this preview", "The current preview cannot resolve or change remote branch context yet.", "Use prisma app deploy for preview app deployment workflows.", ["prisma app deploy --app <name>"], "branch");
+}
+//#endregion
+export { runBranchList, runBranchShow, runBranchUse };

package/dist/controllers/project.js

@@ -0,0 +1,214 @@
+import { UnsafeConfigWriteError, readLinkedProjectId, writeLinkedProjectId } from "../adapters/config.js";
+import { CliError, authRequiredError, usageError } from "../shell/errors.js";
+import { canPrompt } from "../shell/runtime.js";
+import { requireComputeAuth } from "../lib/auth/guard.js";
+import { createProjectUseCases, projectNotFoundError } from "../use-cases/project.js";
+import { createSelectPromptPort } from "./select-prompt-port.js";
+import { createAuthUseCases } from "../use-cases/auth.js";
+import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
+import { readAuthState } from "../lib/auth/auth-ops.js";
+import { requireAuthenticatedAuthState } from "./auth.js";
+//#region src/controllers/project.ts
+function isRealMode(context) {
+	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
+}
+async function runProjectList(context) {
+	if (isRealMode(context)) {
+		const authState = await requireAuthenticatedAuthState(context);
+		const client = await requireComputeAuth(context.runtime.env);
+		const workspace = authState.workspace;
+		if (!client || !workspace) throw authRequiredError();
+		const { data: projectsData } = await client.GET("/v1/projects", {});
+		return {
+			command: "project.list",
+			result: {
+				workspace,
+				linkedProjectId: await readLinkedProjectId(context.runtime.cwd),
+				projects: (projectsData?.data ?? []).filter((project) => project.workspace.id === workspace.id).map((project) => ({
+					id: project.id,
+					name: project.name
+				})).sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id))
+			},
+			warnings: [],
+			nextSteps: ["prisma project link"]
+		};
+	}
+	const authState = await requireAuthenticatedAuthState(context);
+	return {
+		command: "project.list",
+		result: await createProjectUseCases(createCliUseCaseGateways(context)).list(authState),
+		warnings: [],
+		nextSteps: ["prisma project link"]
+	};
+}
+async function runProjectShow(context) {
+	if (isRealMode(context)) {
+		const linkedProjectId = await readLinkedProjectId(context.runtime.cwd);
+		if (!linkedProjectId) return {
+			command: "project.show",
+			result: {
+				linkedProjectId: null,
+				workspace: null,
+				project: null
+			},
+			warnings: [],
+			nextSteps: ["prisma project link"]
+		};
+		const authState = await readAuthState(context.runtime.env);
+		if (!authState.authenticated || !authState.workspace) return {
+			command: "project.show",
+			result: {
+				linkedProjectId,
+				workspace: null,
+				project: null
+			},
+			warnings: [],
+			nextSteps: ["prisma auth login"]
+		};
+		const client = await requireComputeAuth(context.runtime.env);
+		if (!client) return {
+			command: "project.show",
+			result: {
+				linkedProjectId,
+				workspace: null,
+				project: null
+			},
+			warnings: [],
+			nextSteps: ["prisma auth login"]
+		};
+		try {
+			const { data } = await client.GET("/v1/projects/{id}", { params: { path: { id: linkedProjectId } } });
+			const project = data?.data;
+			if (!project || project.workspace.id !== authState.workspace.id) return {
+				command: "project.show",
+				result: {
+					linkedProjectId,
+					workspace: null,
+					project: null
+				},
+				warnings: [],
+				nextSteps: []
+			};
+			return {
+				command: "project.show",
+				result: {
+					linkedProjectId,
+					workspace: {
+						id: project.workspace.id,
+						name: project.workspace.name
+					},
+					project: {
+						id: project.id,
+						name: project.name
+					}
+				},
+				warnings: [],
+				nextSteps: []
+			};
+		} catch {
+			return {
+				command: "project.show",
+				result: {
+					linkedProjectId,
+					workspace: null,
+					project: null
+				},
+				warnings: [],
+				nextSteps: []
+			};
+		}
+	}
+	const gateways = createCliUseCaseGateways(context);
+	const authUseCases = createAuthUseCases(gateways);
+	const projectUseCases = createProjectUseCases(gateways);
+	const authState = await authUseCases.whoami();
+	const result = await projectUseCases.show(authState);
+	return {
+		command: "project.show",
+		result,
+		warnings: [],
+		nextSteps: result.linkedProjectId ? authState.authenticated ? [] : ["prisma auth login"] : ["prisma project link"]
+	};
+}
+async function runProjectLink(context, projectId) {
+	if (!projectId && !canPrompt(context)) throw projectSelectionRequiredError();
+	if (isRealMode(context)) {
+		const authState = await requireAuthenticatedAuthState(context);
+		const client = await requireComputeAuth(context.runtime.env);
+		const workspace = authState.workspace;
+		if (!client || !workspace) throw authRequiredError();
+		let selectedProject;
+		if (projectId) try {
+			const { data } = await client.GET("/v1/projects/{id}", { params: { path: { id: projectId } } });
+			if (!data?.data || data.data.workspace.id !== workspace.id) throw projectNotFoundError(`The project "${projectId}" does not exist in workspace "${workspace.name}".`, "Run prisma project list and choose a project id from the active workspace.");
+			selectedProject = data.data;
+		} catch (error) {
+			if (error instanceof CliError) throw error;
+			throw projectNotFoundError(`The project "${projectId}" does not exist in workspace "${workspace.name}".`, "Run prisma project list and choose a project id from the active workspace.");
+		}
+		else {
+			const { data: projectsData } = await client.GET("/v1/projects", {});
+			const projects = (projectsData?.data ?? []).filter((project) => project.workspace.id === workspace.id).map((project) => ({
+				id: project.id,
+				name: project.name,
+				workspace: project.workspace
+			})).sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
+			if (projects.length === 0) throw projectNotFoundError(`No projects are available in workspace "${workspace.name}".`, "Use prisma app deploy to create project context, or switch workspaces and try again.", []);
+			selectedProject = await createSelectPromptPort(context).select({
+				message: "Select a project",
+				choices: projects.map((project) => ({
+					label: `${project.name} (${project.id})`,
+					value: project
+				}))
+			});
+		}
+		try {
+			await writeLinkedProjectId(context.runtime.cwd, selectedProject.id);
+		} catch (error) {
+			if (error instanceof UnsafeConfigWriteError) throw usageError("Project link requires a writable Prisma config", error.message, "Update prisma.config.ts to use a recognizable project field, or remove it and rerun prisma project link.", ["prisma project link proj_123"], "project");
+			throw error;
+		}
+		return {
+			command: "project.link",
+			result: {
+				linkedProjectId: selectedProject.id,
+				workspace: {
+					id: selectedProject.workspace.id,
+					name: selectedProject.workspace.name
+				},
+				project: {
+					id: selectedProject.id,
+					name: selectedProject.name
+				}
+			},
+			warnings: [],
+			nextSteps: ["prisma project show", "prisma app deploy"]
+		};
+	}
+	const projectUseCases = createProjectUseCases(createCliUseCaseGateways(context));
+	const authState = await requireAuthenticatedAuthState(context);
+	const resolvedProjectId = projectId ?? await resolveProjectIdForLink(context, authState, projectUseCases);
+	return {
+		command: "project.link",
+		result: await projectUseCases.link(authState, resolvedProjectId),
+		warnings: [],
+		nextSteps: ["prisma project show", "prisma app deploy"]
+	};
+}
+async function resolveProjectIdForLink(context, authState, projectUseCases) {
+	if (!authState.workspace) throw projectSelectionRequiredError();
+	const projects = await projectUseCases.listProjectsForWorkspace(authState.workspace.id);
+	if (projects.length === 0) throw projectNotFoundError(`No projects are available in workspace "${authState.workspace.name}".`, "Use prisma app deploy to create project context, or switch workspaces and try again.", []);
+	return (await createSelectPromptPort(context).select({
+		message: "Select a project",
+		choices: projects.map((project) => ({
+			label: `${project.name} (${project.id})`,
+			value: project
+		}))
+	})).id;
+}
+function projectSelectionRequiredError() {
+	return usageError("Project link requires a project target in non-interactive mode", "This command cannot prompt for project selection in the current mode.", "Re-run prisma project link in a TTY, or pass a project id explicitly.", ["prisma project list"], "project");
+}
+//#endregion
+export { runProjectLink, runProjectList, runProjectShow };

package/dist/controllers/select-prompt-port.js

@@ -0,0 +1,12 @@
+import { selectPrompt } from "../shell/prompt.js";
+//#region src/controllers/select-prompt-port.ts
+function createSelectPromptPort(context) {
+	return { select: ({ message, choices }) => selectPrompt({
+		input: context.runtime.stdin,
+		output: context.runtime.stderr,
+		message,
+		choices
+	}) };
+}
+//#endregion
+export { createSelectPromptPort };

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

@@ -0,0 +1,39 @@
+import path from "node:path";
+import { access, readFile } from "node:fs/promises";
+//#region src/lib/app/bun-project.ts
+async function readBunPackageJson(appPath) {
+	const packageJsonPath = path.join(appPath, "package.json");
+	let content;
+	try {
+		content = await readFile(packageJsonPath, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw new Error(`Failed to read ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	try {
+		return JSON.parse(content);
+	} catch (error) {
+		throw new Error(`Failed to parse ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+function readBunPackageEntrypoint(packageJson) {
+	if (typeof packageJson?.main === "string") return packageJson.main;
+	if (typeof packageJson?.module === "string") return packageJson.module;
+}
+async function resolveBunEntrypoint(appPath, explicitEntrypoint) {
+	const packageJson = await readBunPackageJson(appPath);
+	const candidate = explicitEntrypoint ?? readBunPackageEntrypoint(packageJson);
+	if (!candidate) throw new Error("Entrypoint is required. Pass --entry or define package.json main or module.");
+	if (path.isAbsolute(candidate)) throw new Error("Entrypoint must be a relative path.");
+	const normalized = path.normalize(candidate);
+	if (normalized.startsWith("..") || path.isAbsolute(normalized) || normalized.includes(`${path.sep}..${path.sep}`)) throw new Error("Entrypoint must not escape the app directory.");
+	const entrypointPath = path.join(appPath, normalized);
+	try {
+		await access(entrypointPath);
+	} catch {
+		throw new Error(`Entrypoint file does not exist: ${entrypointPath}`);
+	}
+	return normalized.split(path.sep).join("/");
+}
+//#endregion
+export { readBunPackageEntrypoint, readBunPackageJson, resolveBunEntrypoint };

package/dist/lib/app/env-vars.js

@@ -0,0 +1,24 @@
+import { usageError } from "../../shell/errors.js";
+//#region src/lib/app/env-vars.ts
+function parseEnvAssignments(assignments, options) {
+	const values = assignments ?? [];
+	if (options.requireAtLeastOne && values.length === 0) throw usageError("At least one environment variable is required", `prisma app ${options.commandName} needs at least one --env NAME=VALUE flag in the current mode.`, `Pass one or more --env NAME=VALUE flags, for example prisma app ${options.commandName} --env DATABASE_URL=postgresql://example.`, [`prisma app ${options.commandName} --env DATABASE_URL=postgresql://example`], "app");
+	const parsed = {};
+	const seen = /* @__PURE__ */ new Set();
+	for (const assignment of values) {
+		const separatorIndex = assignment.indexOf("=");
+		if (separatorIndex === -1) throw usageError("Environment variable assignment must use NAME=VALUE", "A provided --env flag is missing the = separator.", `Pass repeated --env NAME=VALUE flags, for example prisma app ${options.commandName} --env DATABASE_URL=postgresql://example.`, [`prisma app ${options.commandName} --env DATABASE_URL=postgresql://example`], "app");
+		const name = assignment.slice(0, separatorIndex);
+		if (name.length === 0) throw usageError("Environment variable name is required", "A provided --env flag has an empty variable name.", `Pass repeated --env NAME=VALUE flags, for example prisma app ${options.commandName} --env DATABASE_URL=postgresql://example.`, [`prisma app ${options.commandName} --env DATABASE_URL=postgresql://example`], "app");
+		if (seen.has(name)) throw usageError(`Environment variable "${name}" was provided more than once`, "Each environment variable name may be set only once per command invocation.", `Remove the duplicate "${name}" assignment and rerun prisma app ${options.commandName}.`, [`prisma app ${options.commandName} --env ${name}=value`], "app");
+		seen.add(name);
+		parsed[name] = assignment.slice(separatorIndex + 1);
+	}
+	return parsed;
+}
+function envVarNames(envVars) {
+	if (!envVars) return [];
+	return Object.entries(envVars).filter(([, value]) => value !== null).map(([name]) => name).sort((left, right) => left.localeCompare(right));
+}
+//#endregion
+export { envVarNames, parseEnvAssignments };

package/dist/lib/app/local-dev.js

@@ -0,0 +1,149 @@
+import { readBunPackageEntrypoint, readBunPackageJson, resolveBunEntrypoint } from "./bun-project.js";
+import path from "node:path";
+import { access } from "node:fs/promises";
+import { spawn } from "node:child_process";
+//#region src/lib/app/local-dev.ts
+const NEXT_CONFIG_FILENAMES = [
+	"next.config.js",
+	"next.config.mjs",
+	"next.config.ts",
+	"next.config.mts"
+];
+const DEFAULT_LOCAL_DEV_PORT = 3e3;
+async function resolveLocalBuildType(appPath, buildType) {
+	if (buildType === "bun" || buildType === "nextjs") return buildType;
+	return detectLocalBuildType(appPath);
+}
+async function detectLocalBuildType(appPath) {
+	if (await isNextProject(appPath)) return "nextjs";
+	if (await isBunProject(appPath)) return "bun";
+	return null;
+}
+async function runLocalApp(options) {
+	const spawnImpl = options.spawnImpl ?? spawn;
+	if (options.buildType === "nextjs") {
+		const command = await runWithFallback([
+			{
+				command: path.join(options.appPath, "node_modules", ".bin", process.platform === "win32" ? "next.cmd" : "next"),
+				args: [
+					"dev",
+					"--port",
+					String(options.port)
+				],
+				display: `next dev --port ${options.port}`
+			},
+			{
+				command: "npx",
+				args: [
+					"next",
+					"dev",
+					"--port",
+					String(options.port)
+				],
+				display: `next dev --port ${options.port}`
+			},
+			{
+				command: "bunx",
+				args: [
+					"next",
+					"dev",
+					"--port",
+					String(options.port)
+				],
+				display: `next dev --port ${options.port}`
+			}
+		], {
+			cwd: options.appPath,
+			env: {
+				...options.env,
+				PORT: String(options.port)
+			}
+		}, spawnImpl, "Could not find the Next.js CLI. Install it with `npm install next` or ensure npx/bunx is available.");
+		return {
+			framework: "nextjs",
+			entrypoint: null,
+			port: options.port,
+			command: command.display,
+			exitCode: command.exitCode,
+			signal: command.signal
+		};
+	}
+	const entrypoint = await resolveBunEntrypoint(options.appPath, options.entrypoint);
+	const command = await runWithFallback([{
+		command: "bun",
+		args: ["--watch", entrypoint],
+		display: `bun --watch ${entrypoint}`
+	}], {
+		cwd: options.appPath,
+		env: {
+			...options.env,
+			PORT: String(options.port)
+		}
+	}, spawnImpl, "Bun is required to run this app locally. Install it from https://bun.sh.");
+	return {
+		framework: "bun",
+		entrypoint,
+		port: options.port,
+		command: command.display,
+		exitCode: command.exitCode,
+		signal: command.signal
+	};
+}
+async function isNextProject(appPath) {
+	for (const fileName of NEXT_CONFIG_FILENAMES) try {
+		await access(path.join(appPath, fileName));
+		return true;
+	} catch {}
+	return hasDependency(await readBunPackageJson(appPath), "next");
+}
+async function isBunProject(appPath) {
+	try {
+		await access(path.join(appPath, "bun.lock"));
+		return true;
+	} catch {}
+	try {
+		await access(path.join(appPath, "bun.lockb"));
+		return true;
+	} catch {}
+	const packageJson = await readBunPackageJson(appPath);
+	if (!packageJson) return false;
+	const hasEntrypoint = typeof readBunPackageEntrypoint(packageJson) === "string";
+	const hasBunDependency = hasDependency(packageJson, "@types/bun") || hasDependency(packageJson, "bun");
+	const usesBunScripts = (typeof packageJson.scripts === "object" && packageJson.scripts !== null ? Object.values(packageJson.scripts) : []).some((value) => typeof value === "string" && /\bbun\b/.test(value));
+	return hasEntrypoint && (hasBunDependency || usesBunScripts);
+}
+function hasDependency(packageJson, dependencyName) {
+	if (!packageJson) return false;
+	return [packageJson.dependencies, packageJson.devDependencies].some((group) => typeof group === "object" && group !== null && dependencyName in group);
+}
+async function runWithFallback(candidates, options, spawnImpl, missingCommandMessage) {
+	for (const candidate of candidates) try {
+		const result = await spawnCommand(candidate, options, spawnImpl);
+		return {
+			display: candidate.display,
+			exitCode: result.exitCode,
+			signal: result.signal
+		};
+	} catch (error) {
+		if (error.code === "ENOENT") continue;
+		throw error;
+	}
+	throw new Error(missingCommandMessage);
+}
+function spawnCommand(candidate, options, spawnImpl) {
+	return new Promise((resolve, reject) => {
+		const child = spawnImpl(candidate.command, candidate.args, {
+			...options,
+			stdio: "inherit"
+		});
+		child.once("error", reject);
+		child.once("exit", (code, signal) => {
+			resolve({
+				exitCode: code ?? 1,
+				signal
+			});
+		});
+	});
+}
+//#endregion
+export { DEFAULT_LOCAL_DEV_PORT, resolveLocalBuildType, runLocalApp };