@prisma/cli 3.0.0-beta.10 → 3.0.0-beta.11

package/dist/controllers/branch.js

@@ -1,6 +1,6 @@
 import { CliError, authRequiredError, workspaceRequiredError } from "../shell/errors.js";
-import { requireComputeAuth } from "../lib/auth/guard.js";
 import { projectResolutionErrorToCliError, resolveProjectTarget } from "../lib/project/resolution.js";
+import { requireComputeAuth } from "../lib/auth/guard.js";
 import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
 import { listRealWorkspaceProjects } from "./project.js";

package/dist/controllers/database.js

@@ -1,6 +1,6 @@
 import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../shell/errors.js";
-import { requireComputeAuth } from "../lib/auth/guard.js";
 import { projectResolutionErrorToCliError, resolveProjectTarget } from "../lib/project/resolution.js";
+import { requireComputeAuth } from "../lib/auth/guard.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
 import { listFixtureWorkspaceProjects, listRealWorkspaceProjects } from "./project.js";
 import { createManagementDatabaseProvider, normalizeConnection, normalizeDatabase } from "../lib/database/provider.js";

package/dist/controllers/project.js

@@ -1,19 +1,19 @@
 import { CliError, authRequiredError, featureUnavailableError, usageError, workspaceRequiredError } from "../shell/errors.js";
 import { renderSummaryLine } from "../shell/ui.js";
 import { canPrompt } from "../shell/runtime.js";
-import { requireComputeAuth } from "../lib/auth/guard.js";
-import { formatCommandArgument } from "../shell/command-arguments.js";
 import { readLocalResolutionPin } from "../lib/project/local-pin.js";
+import { formatCommandArgument } from "../shell/command-arguments.js";
 import { buildProjectSetupNextActions, inferTargetName, inspectProjectBinding, projectResolutionErrorToCliError, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
 import { bindProjectToDirectory, isValidProjectSetupName, projectCreateFailedError, projectDirectoryBindingErrorToCliError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
-import { promptForProjectSetupChoice } from "../lib/project/interactive-setup.js";
 import { createPreviewAppProvider } from "../lib/app/preview-provider.js";
+import { requireComputeAuth } from "../lib/auth/guard.js";
+import { promptForProjectSetupChoice } from "../lib/project/interactive-setup.js";
 import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
 import { parseGitHubRepositoryUrl, readGitOriginRemote } from "../adapters/git.js";
 import { createProjectUseCases } from "../use-cases/project.js";
-import open from "open";
 import { matchError } from "better-result";
+import open from "open";
 //#region src/controllers/project.ts
 const GITHUB_INSTALL_POLL_INTERVAL_MS = 2e3;
 const GITHUB_INSTALL_POLL_TIMEOUT_MS = 12e4;

package/dist/lib/app/branch-database-deploy.js

@@ -1,10 +1,10 @@
 import { CliError, usageError } from "../../shell/errors.js";
+import { confirmPrompt } from "../../shell/prompt.js";
 import { renderSummaryLine } from "../../shell/ui.js";
 import { canPrompt } from "../../shell/runtime.js";
-import { confirmPrompt } from "../../shell/prompt.js";
 import { formatCommandArgument } from "../../shell/command-arguments.js";
 import "../project/setup.js";
-import { hasBranchDatabaseSignal, inspectBranchDatabaseSignal, runBranchDatabaseSchemaSetup } from "./branch-database.js";
+import { hasBranchDatabaseSignal, inspectBranchDatabaseSignal } from "./branch-database.js";
 import path from "node:path";
 //#region src/lib/app/branch-database-deploy.ts
 async function maybeSetupBranchDatabase(context, provider, projectId, branch, options) {
@@ -26,13 +26,12 @@ async function maybeSetupBranchDatabase(context, provider, projectId, branch, op
 			result: options.db === true ? {
 				status: "skipped",
 				reason: existingDatabaseEnvReason(branch),
-				envVars: targetEnvVars,
-				schema: null
+				envVars: targetEnvVars
 			} : void 0,
 			warnings: warning ? [warning] : []
 		};
 	}
-	const localSignal = await inspectBranchDatabaseSignal(context.runtime.cwd, context.runtime.signal);
+	const localSignal = await inspectBranchDatabaseSignal(options.projectDir, context.runtime.signal);
 	if (localSignal.unsupportedSchema) {
 		if (options.db === true) throw unsupportedBranchDatabaseSchemaError(localSignal.unsupportedSchema, branch, context);
 		return emptyBranchDatabaseSetupOutcome();
@@ -56,9 +55,9 @@ async function maybeSetupBranchDatabase(context, provider, projectId, branch, op
 			initialValue: false
 		})) return emptyBranchDatabaseSetupOutcome();
 	} else if (!canPrompt(context) && !context.flags.yes) throw nonInteractiveDatabaseSetupRequiresYesError(branch);
-	return setupBranchDatabase(context, provider, projectId, branch, localSignal, envState);
+	return setupBranchDatabase(context, provider, projectId, branch, localSignal, envState, options.projectDir);
 }
-async function setupBranchDatabase(context, provider, projectId, branch, signal, envState) {
+async function setupBranchDatabase(context, provider, projectId, branch, signal, envState, projectDir) {
 	emitBranchDatabaseProgress(context, "pending", "Creating database");
 	const database = await provider.createBranchDatabase({
 		projectId,
@@ -70,27 +69,11 @@ async function setupBranchDatabase(context, provider, projectId, branch, signal,
 	});
 	emitBranchDatabaseProgress(context, "success", "Created database");
 	try {
-		let schemaSetup = null;
-		const warnings = [];
-		let skippedSchemaWarning = null;
-		if (signal.schema) {
-			emitBranchDatabaseProgress(context, "pending", `Applying database schema with ${formatSchemaSetupCommand(signal.schema.command)}`);
-			schemaSetup = await runBranchDatabaseSchemaSetup({
-				context,
-				schema: signal.schema,
-				databaseUrl: database.databaseUrl,
-				directUrl: database.directUrl
-			}).catch((error) => {
-				throw schemaSetupFailedError(error, signal.schema, branch, context.runtime.cwd);
-			});
-			emitBranchDatabaseProgress(context, "success", "Applied database schema");
-		} else skippedSchemaWarning = "No supported Prisma schema source was found. Database env vars were created, but schema setup was skipped.";
 		const envVars = await upsertBranchDatabaseEnvVars(context, provider, projectId, branch, database, envState);
-		emitBranchDatabaseProgress(context, "success", `Added ${envScopeLabel(branch)} env var${envVars.length === 1 ? "" : "s"} ${envVars.join(", ")}`);
-		if (skippedSchemaWarning) {
-			emitBranchDatabaseWarning(context, skippedSchemaWarning);
-			warnings.push(skippedSchemaWarning);
-		}
+		emitBranchDatabaseProgress(context, "success", `Added ${envScopeLabel(branch)} env var${envVars.length === 1 ? "" : "s"} ${envVars.join(", ")} — shared by every app on ${envScopeLabel(branch) === "production" ? "production" : `branch "${branch.name}"`}`);
+		const schemaCommand = signal.schema ? `DATABASE_URL=<url> npx ${formatSchemaSetupCommand(signal.schema.command)} (detected ${path.relative(projectDir, signal.schema.path) || signal.schema.path})` : "your own migration tooling";
+		const schemaSuggestion = `The new database is empty. Get a connection URL with \`prisma-cli database connection create ${database.id}\`, then apply your schema with ${schemaCommand}.`;
+		emitBranchDatabaseWarning(context, schemaSuggestion);
 		return {
 			result: {
 				status: "created",
@@ -98,14 +81,9 @@ async function setupBranchDatabase(context, provider, projectId, branch, signal,
 					id: database.id,
 					name: database.name
 				},
-				envVars,
-				schema: schemaSetup ? {
-					command: schemaSetup.command,
-					source: schemaSetup.source,
-					path: schemaSetup.schemaPath
-				} : null
+				envVars
 			},
-			warnings
+			warnings: [schemaSuggestion]
 		};
 	} catch (error) {
 		throw await cleanupCreatedBranchDatabaseAfterFailure(context, provider, database, branch, error);
@@ -307,24 +285,6 @@ function branchDatabaseCleanupFailedError(setupError, cleanupError, database, br
 		nextSteps: []
 	});
 }
-function schemaSetupFailedError(error, schema, branch, cwd) {
-	return new CliError({
-		code: "SCHEMA_SETUP_FAILED",
-		domain: "app",
-		summary: "Database schema setup failed",
-		why: error instanceof Error ? error.message : String(error),
-		fix: "Fix the Prisma schema or migrations, then rerun deploy with --db.",
-		debug: formatDebugDetails(error),
-		meta: {
-			branch: branch.name,
-			schemaPath: schema.path,
-			source: schema.kind,
-			command: schema.command
-		},
-		exitCode: 1,
-		nextSteps: [...formatSchemaSetupNextSteps(schema, cwd), formatAppDeployWithDbNextStep(branch)]
-	});
-}
 function unsupportedBranchDatabaseSchemaError(schema, branch, context) {
 	return usageError("Database setup is not available for this Prisma schema", `${path.relative(context.runtime.cwd, schema.path) || defaultUnsupportedSchemaSourcePath(schema)} targets ${formatUnsupportedSchemaTarget(schema.target)}, but --db creates Prisma Postgres databases.`, "Use project env commands to provide a database URL, or switch the Prisma schema source to PostgreSQL before using --db.", [formatProjectEnvAddNextStep(branch), `prisma-cli app deploy --branch ${formatCommandArgument(branch.name)}`], "app");
 }
@@ -337,14 +297,6 @@ function formatProjectEnvListNextStep(branch) {
 function formatProjectEnvAddNextStep(branch) {
 	return branch.kind === "production" ? "prisma-cli project env add DATABASE_URL=<value> --role production" : `prisma-cli project env add DATABASE_URL=<value> --branch ${formatCommandArgument(branch.name)}`;
 }
-function formatSchemaSetupNextSteps(schema, cwd) {
-	const sourcePath = path.relative(cwd, schema.path) || defaultSchemaSourcePath(schema);
-	switch (schema.command) {
-		case "migrate-deploy": return [`npx --no-install prisma migrate deploy --schema ${formatCommandArgument(sourcePath)}`];
-		case "db-push": return [`npx --no-install prisma db push --schema ${formatCommandArgument(sourcePath)}`];
-		case "prisma-next-db-init": return [`npx --no-install prisma-next contract emit --config ${formatCommandArgument(sourcePath)}`, `npx --no-install prisma-next db init --config ${formatCommandArgument(sourcePath)} --db <DATABASE_URL>`];
-	}
-}
 function defaultSchemaSourcePath(schema) {
 	return schema.kind === "prisma-next" ? "prisma-next.config.ts" : "schema.prisma";
 }

package/dist/lib/app/branch-database.js

@@ -1,6 +1,5 @@
 import { access, readFile, readdir, stat } from "node:fs/promises";
 import path from "node:path";
-import { spawn } from "node:child_process";
 //#region src/lib/app/branch-database.ts
 const SKIPPED_DIRECTORIES = new Set([
 	".git",
@@ -67,23 +66,6 @@ function hasBranchDatabaseSignal(signal) {
 	if (signal.unsupportedSchema) return false;
 	return Boolean(signal.schema || signal.databaseUrlReferences.length > 0);
 }
-async function runBranchDatabaseSchemaSetup(options) {
-	const schemaPath = path.relative(options.context.runtime.cwd, options.schema.path) || defaultSchemaSourcePath(options.schema);
-	const commands = buildSchemaSetupCommands(options.schema, schemaPath, options.databaseUrl);
-	for (const command of commands) await runPrismaCommand({
-		context: options.context,
-		...command,
-		env: {
-			DATABASE_URL: options.databaseUrl,
-			...options.directUrl ? { DIRECT_URL: options.directUrl } : {}
-		}
-	});
-	return {
-		command: options.schema.command,
-		source: options.schema.kind,
-		schemaPath
-	};
-}
 async function scanDirectory(cwd, directory, depth, state, signal) {
 	signal.throwIfAborted();
 	if (depth > MAX_SCAN_DEPTH || state.filesVisited >= MAX_SCAN_FILES) return;
@@ -229,88 +211,5 @@ async function readTextFileIfSmall(filePath, signal) {
 		signal
 	});
 }
-function buildSchemaSetupCommands(schema, schemaPath, databaseUrl) {
-	if (schema.command === "migrate-deploy") return [{
-		args: [
-			"--no-install",
-			"prisma",
-			"migrate",
-			"deploy",
-			"--schema",
-			schemaPath
-		],
-		displayCommand: "npx --no-install prisma migrate deploy"
-	}];
-	if (schema.command === "db-push") return [{
-		args: [
-			"--no-install",
-			"prisma",
-			"db",
-			"push",
-			"--schema",
-			schemaPath
-		],
-		displayCommand: "npx --no-install prisma db push"
-	}];
-	return [{
-		args: [
-			"--no-install",
-			"prisma-next",
-			"contract",
-			"emit",
-			"--config",
-			schemaPath
-		],
-		displayCommand: "npx --no-install prisma-next contract emit"
-	}, {
-		args: [
-			"--no-install",
-			"prisma-next",
-			"db",
-			"init",
-			"--config",
-			schemaPath,
-			"--db",
-			databaseUrl
-		],
-		displayCommand: "npx --no-install prisma-next db init"
-	}];
-}
-function defaultSchemaSourcePath(schema) {
-	return schema.kind === "prisma-next" ? "prisma-next.config.ts" : "schema.prisma";
-}
-async function runPrismaCommand(options) {
-	const shouldPipeOutput = !options.context.flags.json && !options.context.flags.quiet;
-	const child = spawn("npx", options.args, {
-		cwd: options.context.runtime.cwd,
-		env: {
-			...options.context.runtime.env,
-			...options.env
-		},
-		signal: options.context.runtime.signal,
-		stdio: shouldPipeOutput ? [
-			"ignore",
-			"pipe",
-			"pipe"
-		] : [
-			"ignore",
-			"ignore",
-			"ignore"
-		]
-	});
-	if (shouldPipeOutput) {
-		child.stdout?.pipe(options.context.output.stderr, { end: false });
-		child.stderr?.pipe(options.context.output.stderr, { end: false });
-	}
-	const exit = await new Promise((resolve, reject) => {
-		child.once("error", reject);
-		child.once("close", (code, signal) => resolve({
-			code,
-			signal
-		}));
-	});
-	if (exit.signal) throw new Error(`${options.displayCommand} was terminated by ${exit.signal}.`);
-	if (exit.code !== 0) throw new Error(`${options.displayCommand} exited with code ${exit.code ?? 1}.`);
-}
 //#endregion
-export { hasBranchDatabaseSignal, inspectBranchDatabaseSignal, runBranchDatabaseSchemaSetup };
+export { hasBranchDatabaseSignal, inspectBranchDatabaseSignal };

package/dist/lib/app/compute-config.js

@@ -0,0 +1,147 @@
+import { CliError } from "../../shell/errors.js";
+import { COMPUTE_CONFIG_FILENAME, COMPUTE_CONFIG_FILENAME as COMPUTE_CONFIG_FILENAME$1, ComputeConfigTargetRequiredError, computeTargetAppDir, frameworkByKey, inferComputeTargetFromCwd, loadComputeConfig, selectComputeDeployTarget } from "@prisma/compute-sdk/config";
+import path from "node:path";
+import { matchError } from "better-result";
+//#region src/lib/app/compute-config.ts
+/**
+* Loads the nearest compute config, searching from `cwd` up to the source
+* root (repository or workspace boundary). Thin adapter over the SDK loader
+* keeping the CLI's positional-signal call shape.
+*/
+async function loadComputeConfig$1(cwd, signal) {
+	return loadComputeConfig(cwd, { signal });
+}
+/** Local build/run strategy implied by a configured framework. */
+function computeFrameworkToBuildType(framework) {
+	return frameworkByKey(framework).buildType;
+}
+function mergeComputeDeployInputs(options) {
+	const { cli, target, configFilename } = options;
+	const configAnnotation = `set by ${configFilename}`;
+	const framework = cli.framework ? {
+		value: cli.framework,
+		annotation: "set by --framework"
+	} : target?.framework ? {
+		value: target.framework,
+		annotation: configAnnotation
+	} : void 0;
+	const entrypoint = cli.entrypoint ? {
+		value: cli.entrypoint,
+		annotation: "set by --entry"
+	} : target?.entry ? {
+		value: target.entry,
+		annotation: configAnnotation
+	} : void 0;
+	const httpPort = cli.httpPort ? {
+		value: cli.httpPort,
+		annotation: "set by --http-port"
+	} : target?.httpPort ? {
+		value: String(target.httpPort),
+		annotation: configAnnotation
+	} : void 0;
+	const cliEnvInputs = cli.envInputs && cli.envInputs.length > 0 ? cli.envInputs : void 0;
+	const configEnvInputs = target && target.envInputs.length > 0 ? target.envInputs : void 0;
+	const envInputs = cliEnvInputs ?? configEnvInputs;
+	const configAppName = target?.name ? {
+		value: target.name,
+		annotation: configAnnotation
+	} : target?.key ? {
+		value: target.key,
+		annotation: configAnnotation
+	} : void 0;
+	return {
+		framework,
+		entrypoint,
+		httpPort,
+		envInputs,
+		envInputsFromConfig: !cliEnvInputs && configEnvInputs !== void 0,
+		configAppName,
+		appRoot: target?.root ?? void 0
+	};
+}
+/**
+* Merges CLI inputs for the local `app build` and `app run` commands with a
+* selected config target. Explicit flags win; `--build-type auto` is the
+* flag default and defers to the configured framework.
+*/
+function mergeComputeLocalInputs(options) {
+	const { cli, target } = options;
+	const cliBuildType = cli.buildType && cli.buildType !== "auto" ? cli.buildType : void 0;
+	const configBuildType = target?.framework ? computeFrameworkToBuildType(target.framework) : void 0;
+	return {
+		entrypoint: cli.entrypoint ?? target?.entry ?? void 0,
+		buildType: cliBuildType ?? configBuildType,
+		buildTypeFromConfig: !cliBuildType && configBuildType !== void 0,
+		port: cli.port ?? (target?.httpPort ? String(target.httpPort) : void 0),
+		appRoot: target?.root ?? void 0
+	};
+}
+function computeConfigErrorToCliError(error, commandName = "deploy") {
+	const command = `prisma-cli app ${commandName}`;
+	return matchError(error, {
+		ComputeConfigAmbiguousError: (ambiguous) => new CliError({
+			code: "COMPUTE_CONFIG_INVALID",
+			domain: "app",
+			summary: "Multiple compute config files found",
+			why: ambiguous.message,
+			fix: `Keep exactly one compute config file, preferably ${COMPUTE_CONFIG_FILENAME}.`,
+			meta: { configPaths: ambiguous.configPaths },
+			exitCode: 2,
+			nextSteps: [command]
+		}),
+		ComputeConfigLoadError: (load) => new CliError({
+			code: "COMPUTE_CONFIG_INVALID",
+			domain: "app",
+			summary: `Could not load ${path.basename(load.configPath)}`,
+			why: load.message,
+			fix: `Fix the error in ${path.basename(load.configPath)} and rerun the command.`,
+			where: load.configPath,
+			meta: { configPath: load.configPath },
+			exitCode: 2,
+			nextSteps: [command]
+		}),
+		ComputeConfigInvalidError: (invalid) => new CliError({
+			code: "COMPUTE_CONFIG_INVALID",
+			domain: "app",
+			summary: `Invalid ${path.basename(invalid.configPath)}`,
+			why: invalid.issues.join(" "),
+			fix: `Edit ${path.basename(invalid.configPath)} so it default-exports defineComputeConfig({ app }) or defineComputeConfig({ apps }).`,
+			where: invalid.configPath,
+			meta: {
+				configPath: invalid.configPath,
+				issues: invalid.issues
+			},
+			exitCode: 2,
+			nextSteps: [command]
+		}),
+		ComputeConfigTargetRequiredError: (required) => new CliError({
+			code: "COMPUTE_CONFIG_TARGET_REQUIRED",
+			domain: "app",
+			summary: "App target required",
+			why: required.message,
+			fix: `Pass the app target, for example ${command} <target>.`,
+			meta: {
+				configPath: required.configPath,
+				availableTargets: required.availableTargets
+			},
+			exitCode: 2,
+			nextSteps: required.availableTargets.map((target) => `${command} ${target}`)
+		}),
+		ComputeConfigTargetUnknownError: (unknown) => new CliError({
+			code: "COMPUTE_CONFIG_TARGET_UNKNOWN",
+			domain: "app",
+			summary: `Unknown app target "${unknown.requestedTarget}"`,
+			why: unknown.message,
+			fix: unknown.availableTargets.length > 0 ? `Pass one of the configured targets: ${unknown.availableTargets.join(", ")}.` : "Remove the target argument; this config defines a single app.",
+			meta: {
+				configPath: unknown.configPath,
+				requestedTarget: unknown.requestedTarget,
+				availableTargets: unknown.availableTargets
+			},
+			exitCode: 2,
+			nextSteps: unknown.availableTargets.length > 0 ? unknown.availableTargets.map((target) => `${command} ${target}`) : [command]
+		})
+	});
+}
+//#endregion
+export { COMPUTE_CONFIG_FILENAME$1 as COMPUTE_CONFIG_FILENAME, ComputeConfigTargetRequiredError, computeConfigErrorToCliError, computeFrameworkToBuildType, computeTargetAppDir, inferComputeTargetFromCwd, loadComputeConfig$1 as loadComputeConfig, mergeComputeDeployInputs, mergeComputeLocalInputs, selectComputeDeployTarget };

package/dist/lib/app/deploy-plan.js

@@ -0,0 +1,58 @@
+//#region src/lib/app/deploy-plan.ts
+/**
+* Decides whether a deploy covers one app or the whole system. A multi-app
+* config with no target named or inferred deploys every target in declaration
+* order; everything else (single-app config, an explicit/inferred target, or
+* no config at all) is a single deploy.
+*/
+function planAppDeploy(options) {
+	const { config, requestedTarget, hasCreateProject } = options;
+	if (!(config !== null && config.kind === "multi" && !requestedTarget && config.targets.length > 1)) return { mode: "single" };
+	const total = config.targets.length;
+	return {
+		mode: "all",
+		targets: config.targets.map((target, index) => ({
+			targetKey: target.key,
+			index,
+			total,
+			bindsCreateProject: index === 0 && hasCreateProject
+		}))
+	};
+}
+/**
+* Names the per-app inputs present in a deploy-all invocation, in the order
+* they should be reported. An empty list means the run is unambiguous; the
+* caller renders the usage error when it is not.
+*/
+function perAppInputsForDeployAll(inputs) {
+	return [
+		["--app", inputs.appName],
+		["--framework", inputs.framework],
+		["--entry", inputs.entrypoint],
+		["--http-port", inputs.httpPort],
+		["--env", inputs.envAssignments?.length ? inputs.envAssignments : void 0],
+		[inputs.appIdEnvVar.name, inputs.appIdEnvVar.value]
+	].filter(([, value]) => value !== void 0).map(([flag]) => flag);
+}
+/**
+* Describes a deploy-all run that stopped at the first failing target: which
+* targets already went live and which were never attempted, so the caller can
+* surface a converge path. Pure; the caller folds this into the CliError.
+*/
+function describeDeployAllFailure(options) {
+	const { targetKeys, failedIndex, completed } = options;
+	const failedTarget = targetKeys[failedIndex];
+	const notAttempted = targetKeys.slice(failedIndex + 1);
+	return {
+		failedTarget,
+		completed,
+		notAttempted,
+		contextLines: [
+			`Deploying all apps stopped at "${failedTarget}" (${failedIndex + 1}/${targetKeys.length}).`,
+			...completed.length > 0 ? [`Already live: ${completed.map((entry) => entry.target).join(", ")}.`] : [],
+			...notAttempted.length > 0 ? [`Not attempted: ${notAttempted.join(", ")}.`] : []
+		]
+	};
+}
+//#endregion
+export { describeDeployAllFailure, perAppInputsForDeployAll, planAppDeploy };

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

@@ -1,25 +1,9 @@
-import { readBunPackageEntrypoint, readBunPackageJson, resolveBunEntrypoint } from "./bun-project.js";
-import { access } from "node:fs/promises";
+import { resolveBunEntrypoint } from "./bun-project.js";
+import "node:fs/promises";
 import path from "node:path";
 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, signal) {
-	if (buildType === "bun" || buildType === "nextjs") return buildType;
-	if (buildType !== "auto") return null;
-	return detectLocalBuildType(appPath, signal);
-}
-async function detectLocalBuildType(appPath, signal) {
-	if (await isNextProject(appPath, signal)) return "nextjs";
-	if (await isBunProject(appPath, signal)) return "bun";
-	return null;
-}
 async function runLocalApp(options) {
 	const spawnImpl = options.spawnImpl ?? spawn;
 	if (options.buildType === "nextjs") {
@@ -92,47 +76,6 @@ async function runLocalApp(options) {
 		signal: command.signal
 	};
 }
-async function isNextProject(appPath, signal) {
-	for (const fileName of NEXT_CONFIG_FILENAMES) {
-		signal?.throwIfAborted();
-		try {
-			await access(path.join(appPath, fileName));
-			signal?.throwIfAborted();
-			return true;
-		} catch (error) {
-			if (signal?.aborted) throw error;
-		}
-	}
-	return hasDependency(await readBunPackageJson(appPath, signal), "next");
-}
-async function isBunProject(appPath, signal) {
-	signal?.throwIfAborted();
-	try {
-		await access(path.join(appPath, "bun.lock"));
-		signal?.throwIfAborted();
-		return true;
-	} catch (error) {
-		if (signal?.aborted) throw error;
-	}
-	signal?.throwIfAborted();
-	try {
-		await access(path.join(appPath, "bun.lockb"));
-		signal?.throwIfAborted();
-		return true;
-	} catch (error) {
-		if (signal?.aborted) throw error;
-	}
-	const packageJson = await readBunPackageJson(appPath, signal);
-	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);
@@ -163,4 +106,4 @@ function spawnCommand(candidate, options, spawnImpl) {
 	});
 }
 //#endregion
-export { DEFAULT_LOCAL_DEV_PORT, resolveLocalBuildType, runLocalApp };
+export { DEFAULT_LOCAL_DEV_PORT, runLocalApp };