@prisma/cli 3.0.0-beta.9 → 3.0.0-dev.101.1

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 };

package/dist/lib/app/production-deploy-gate.js

@@ -1,6 +1,6 @@
 import { CliError } from "../../shell/errors.js";
-import { canPrompt } from "../../shell/runtime.js";
 import { confirmPrompt } from "../../shell/prompt.js";
+import { canPrompt } from "../../shell/runtime.js";
 //#region src/lib/app/production-deploy-gate.ts
 async function enforceProductionDeployGate(context, provider, options) {
 	if (options.branchKind !== "production") return { firstProductionDeploy: false };
@@ -104,12 +104,12 @@ function productionDeployRequiresFlagError() {
 			"",
 			"Production deploys require explicit intent. Re-run with:",
 			"",
-			"  prisma app deploy --prod",
+			"  prisma-cli app deploy --prod",
 			"",
 			"Or deploy a preview from a feature branch:",
 			"",
 			"  git checkout -b <branch-name>",
-			"  prisma app deploy"
+			"  prisma-cli app deploy"
 		]
 	});
 }

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

@@ -0,0 +1,30 @@
+//#region src/lib/app/read-branch.ts
+/**
+* Resolves the branch an app management command should read from, without ever
+* creating one. Returns the branch whose `gitName` matches `branchName`, else
+* the project's default branch, else null when the project has no branches.
+*/
+async function resolveReadBranch(client, options) {
+	const branches = [];
+	let cursor;
+	do {
+		const result = await client.GET("/v1/projects/{projectId}/branches", {
+			params: {
+				path: { projectId: options.projectId },
+				query: { cursor }
+			},
+			signal: options.signal
+		});
+		if (result.error || !result.data) throw new Error(`Failed to list branches for project ${options.projectId}: ${JSON.stringify(result.error)}`);
+		branches.push(...result.data.data);
+		cursor = result.data.pagination.hasMore ? result.data.pagination.nextCursor ?? void 0 : void 0;
+	} while (cursor);
+	const chosen = branches.find((branch) => branch.gitName === options.branchName) ?? branches.find((branch) => branch.isDefault) ?? null;
+	return chosen ? {
+		id: chosen.id,
+		name: chosen.gitName,
+		kind: chosen.role
+	} : null;
+}
+//#endregion
+export { resolveReadBranch };

package/dist/lib/auth/auth-ops.js

@@ -26,7 +26,7 @@ function workspaceIdFromClaims(claims) {
 }
 async function performLogin(env, signal) {
 	await login({
-		tokenStorage: new FileTokenStorage(env, signal),
+		tokenStorage: new FileTokenStorage(env, signal, { activateOnSetTokens: true }),
 		env,
 		signal
 	});
@@ -38,7 +38,8 @@ async function readAuthState(env, signal) {
 		if (serviceToken.length === 0) throw new Error(`${SERVICE_TOKEN_ENV_VAR} is set but empty. Provide a valid token or unset the variable.`);
 		return readServiceTokenAuthState(serviceToken, env, signal);
 	}
-	const tokens = await new FileTokenStorage(env, signal).getTokens();
+	const tokenStorage = new FileTokenStorage(env, signal);
+	const tokens = await tokenStorage.getTokens();
 	if (!tokens) return {
 		authenticated: false,
 		provider: null,
@@ -48,15 +49,20 @@ async function readAuthState(env, signal) {
 	};
 	const client = await requireComputeAuth(env, signal);
 	const currentPrincipal = await readCurrentPrincipalAuthState(client, signal);
-	if (currentPrincipal) return currentPrincipal;
+	if (currentPrincipal) {
+		if (currentPrincipal.authenticated && currentPrincipal.workspace) await tokenStorage.rememberWorkspace?.(tokens.workspaceId, currentPrincipal.workspace);
+		return currentPrincipal;
+	}
 	const claims = decodeJwtPayload(tokens.accessToken);
-	return buildAuthState({
+	const authState = await buildAuthState({
 		workspaceIdFromCredential: tokens.workspaceId,
 		claims,
 		env,
 		client,
 		signal
 	});
+	if (authState.authenticated && authState.workspace) await tokenStorage.rememberWorkspace?.(tokens.workspaceId, authState.workspace);
+	return authState;
 }
 async function readServiceTokenAuthState(token, env, signal) {
 	const client = await requireComputeAuth(env, signal);

package/dist/lib/auth/guard.js

@@ -22,7 +22,10 @@ async function requireComputeAuth(env = process.env, signal) {
 			token
 		});
 	}
-	const tokenStorage = new FileTokenStorage(env, signal);
+	const tokenStorage = new FileTokenStorage(env, signal, {
+		activateOnSetTokens: false,
+		lockSetTokens: false
+	});
 	if (!await tokenStorage.getTokens()) return null;
 	return createManagementApiSdk({
 		clientId: CLIENT_ID,

package/dist/lib/auth/login.js

@@ -106,35 +106,42 @@ async function consumePastedCallback(options) {
 	});
 	try {
 		for (;;) {
-			let answer;
-			try {
-				answer = await rl.question("Paste the callback URL here: ", { signal: options.signal });
-			} catch (error) {
-				if (error?.name === "AbortError") return;
-				throw error;
-			}
-			const trimmed = answer.trim().replace(/^["']|["']$/g, "");
-			let url;
-			try {
-				if (!trimmed) throw new Error("empty input");
-				url = new URL(trimmed);
-			} catch {
-				options.output.write("That didn't look like a URL. Paste the full localhost callback URL and try again.\n");
-				continue;
-			}
-			try {
-				await options.complete(url);
-				return;
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				options.output.write(`Sign-in didn't complete (${message}). Paste the callback URL to try again.\n`);
-				continue;
-			}
+			const url = await readPastedCallbackUrl(rl, options);
+			if (url === null) return;
+			if (url === void 0) continue;
+			if (await tryCompletePastedCallback(url, options)) return;
 		}
 	} finally {
 		rl.close();
 	}
 }
+async function readPastedCallbackUrl(rl, options) {
+	let answer;
+	try {
+		answer = await rl.question("Paste the callback URL here: ", { signal: options.signal });
+	} catch (error) {
+		if (error?.name === "AbortError") return null;
+		throw error;
+	}
+	const trimmed = answer.trim().replace(/^["']|["']$/g, "");
+	try {
+		if (!trimmed) throw new Error("empty input");
+		return new URL(trimmed);
+	} catch {
+		options.output.write("That didn't look like a URL. Paste the full localhost callback URL and try again.\n");
+		return;
+	}
+}
+async function tryCompletePastedCallback(url, options) {
+	try {
+		await options.complete(url);
+		return true;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		options.output.write(`Sign-in didn't complete (${message}). Paste the callback URL to try again.\n`);
+		return false;
+	}
+}
 var LoginState = class {
 	latestVerifier;
 	latestState;
@@ -144,7 +151,7 @@ var LoginState = class {
 	output;
 	constructor(options) {
 		this.options = options;
-		this.tokenStorage = options.tokenStorage ?? new FileTokenStorage(options.env, options.signal);
+		this.tokenStorage = options.tokenStorage ?? new FileTokenStorage(options.env, options.signal, { activateOnSetTokens: true });
 		this.sdk = createManagementApiSdk({
 			clientId: options.clientId ?? "cmm3lndn701oo0uefvxzo0ivw",
 			redirectUri: `http://${options.hostname}:${options.port}/auth/callback`,

package/dist/lib/diagnostics.js

@@ -3,7 +3,7 @@ import { resolveStateDir } from "../shell/runtime.js";
 import { readLocalGitState } from "./git/local-status.js";
 //#region src/lib/diagnostics.ts
 async function collectCommandDiagnostics(context, options = {}) {
-	const stateDir = resolveStateDir(context.runtime);
+	const stateDir = await resolveStateDir(context.runtime);
 	return {
 		cwd: context.runtime.cwd,
 		stateFilePath: resolveLocalStateFilePath(stateDir),

package/dist/lib/fs/home-path.js

@@ -0,0 +1,24 @@
+import path from "node:path";
+//#region src/lib/fs/home-path.ts
+/**
+* Shortens a path under the user's home directory to `~/...` for display,
+* posix-style on every platform. Falls back to the Windows home variables
+* when `HOME` is unset (native cmd/PowerShell sessions).
+*/
+function shortenHomePath(value, env) {
+	const resolved = path.resolve(value);
+	const home = resolveHomeDirectory(env);
+	if (home && (resolved === home || resolved.startsWith(`${home}${path.sep}`))) {
+		const relative = path.relative(home, resolved).split(path.sep).join("/");
+		return relative ? `~/${relative}` : "~";
+	}
+	return resolved;
+}
+function resolveHomeDirectory(env) {
+	if (env.HOME) return path.resolve(env.HOME);
+	if (env.USERPROFILE) return path.resolve(env.USERPROFILE);
+	if (env.HOMEDRIVE && env.HOMEPATH) return path.resolve(`${env.HOMEDRIVE}${env.HOMEPATH}`);
+	return null;
+}
+//#endregion
+export { shortenHomePath };

package/dist/lib/git/local-branch.js

@@ -1,9 +1,22 @@
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
 //#region src/lib/git/local-branch.ts
+/**
+* Resolves the checked-out branch the way git does: the nearest `.git`
+* (directory or worktree file) from `cwd` upward owns the answer, so
+* monorepo commands run from inside a package see the repository branch.
+* Returns null for detached HEAD or when no repository contains `cwd`.
+*/
 async function readLocalGitBranch(cwd, signal) {
-	const headPath = await resolveGitHeadPath(path.join(cwd, ".git"), signal);
-	if (!headPath) return null;
+	for (let directory = path.resolve(cwd);;) {
+		const headPath = await resolveGitHeadPath(path.join(directory, ".git"), signal);
+		if (headPath) return readBranchFromHead(headPath, signal);
+		const parent = path.dirname(directory);
+		if (parent === directory) return null;
+		directory = parent;
+	}
+}
+async function readBranchFromHead(headPath, signal) {
 	try {
 		const head = (await readFile(headPath, {
 			encoding: "utf8",
@@ -12,7 +25,6 @@ async function readLocalGitBranch(cwd, signal) {
 		if (head.startsWith("ref: refs/heads/")) return head.slice(16);
 	} catch (error) {
 		if (signal.aborted) throw error;
-		return null;
 	}
 	return null;
 }

package/dist/lib/project/local-pin.js

@@ -29,6 +29,53 @@ var LocalResolutionPinReadAbortedError = class extends TaggedError("LocalResolut
 		});
 	}
 };
+var LocalResolutionPinSerializationError = class extends TaggedError("LocalResolutionPinSerializationError")() {
+	constructor(cause) {
+		super({
+			message: `Could not serialize ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH}.`,
+			cause,
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
+		});
+	}
+};
+var LocalResolutionPinWriteAbortedError = class extends TaggedError("LocalResolutionPinWriteAbortedError")() {
+	constructor(cause) {
+		super({
+			message: `Writing ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} was aborted.`,
+			cause,
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
+		});
+	}
+};
+var LocalResolutionPinWriteFailedError = class extends TaggedError("LocalResolutionPinWriteFailedError")() {
+	constructor(operation, cause) {
+		super({
+			message: `Could not write ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH}.`,
+			cause,
+			operation,
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
+		});
+	}
+};
+var LocalResolutionPinGitignoreUpdateAbortedError = class extends TaggedError("LocalResolutionPinGitignoreUpdateAbortedError")() {
+	constructor(cause) {
+		super({
+			message: "Updating .gitignore for the local Project binding was aborted.",
+			cause,
+			gitignorePath: ".gitignore"
+		});
+	}
+};
+var LocalResolutionPinGitignoreUpdateFailedError = class extends TaggedError("LocalResolutionPinGitignoreUpdateFailedError")() {
+	constructor(operation, cause) {
+		super({
+			message: "Could not update .gitignore for the local Project binding.",
+			cause,
+			operation,
+			gitignorePath: ".gitignore"
+		});
+	}
+};
 async function readLocalResolutionPin(cwd, signal) {
 	return Result.gen(async function* () {
 		yield* ensureLocalResolutionPinReadNotAborted(signal);
@@ -72,41 +119,74 @@ function parseLocalResolutionPin(raw) {
 	});
 }
 async function writeLocalResolutionPin(cwd, pin, signal) {
-	const prismaDir = path.join(cwd, ".prisma");
-	signal?.throwIfAborted();
-	await mkdir(prismaDir, { recursive: true });
-	const pinPath = path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH);
-	const tmpPath = path.join(prismaDir, `local.${process.pid}.${Date.now()}.tmp`);
-	await writeFile(tmpPath, `${JSON.stringify(pin, null, 2)}\n`, {
-		encoding: "utf8",
-		signal
+	return Result.gen(async function* () {
+		const prismaDir = path.join(cwd, ".prisma");
+		yield* ensureLocalResolutionPinWriteNotAborted(signal);
+		yield* Result.await(writeLocalResolutionPinBoundary(() => mkdir(prismaDir, { recursive: true }), "create-directory", signal));
+		const pinPath = path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH);
+		const tmpPath = path.join(prismaDir, `local.${process.pid}.${Date.now()}.tmp`);
+		const serialized = yield* serializeLocalResolutionPin(pin);
+		yield* Result.await(writeLocalResolutionPinBoundary(() => writeFile(tmpPath, serialized, {
+			encoding: "utf8",
+			signal
+		}), "write-temp-file", signal));
+		yield* ensureLocalResolutionPinWriteNotAborted(signal);
+		yield* Result.await(writeLocalResolutionPinBoundary(() => rename(tmpPath, pinPath), "rename-temp-file", signal));
+		return Result.ok(void 0);
 	});
-	signal?.throwIfAborted();
-	await rename(tmpPath, pinPath);
 }
 async function ensureLocalResolutionPinGitignore(cwd, signal) {
 	const gitignorePath = path.join(cwd, ".gitignore");
 	let existing = null;
-	signal?.throwIfAborted();
-	try {
-		existing = await readFile(gitignorePath, {
+	const notAborted = ensureLocalResolutionPinGitignoreUpdateNotAborted(signal);
+	if (notAborted.isErr()) return Result.err(notAborted.error);
+	const existingResult = await Result.tryPromise({
+		try: () => readFile(gitignorePath, {
 			encoding: "utf8",
 			signal
-		});
-	} catch (error) {
-		if (error.code !== "ENOENT") throw error;
-	}
-	if (existing === null) {
-		await writeFile(gitignorePath, ".prisma/\n", {
+		}),
+		catch: (cause) => signal?.aborted ? new LocalResolutionPinGitignoreUpdateAbortedError(cause) : new LocalResolutionPinGitignoreUpdateFailedError("read", cause)
+	});
+	if (existingResult.isErr()) if (existingResult.error instanceof LocalResolutionPinGitignoreUpdateFailedError && existingResult.error.cause.code === "ENOENT") existing = null;
+	else return Result.err(existingResult.error);
+	else existing = existingResult.value;
+	if (existing === null) return writeLocalResolutionPinGitignore(gitignorePath, ".prisma/\n", signal);
+	if (existing.split(/\r?\n/).map((line) => line.trim()).some((line) => line === ".prisma/" || line === ".prisma/local.json")) return Result.ok(void 0);
+	return writeLocalResolutionPinGitignore(gitignorePath, existing.endsWith("\n") ? `${existing}.prisma/\n` : `${existing}\n.prisma/\n`, signal);
+}
+function ensureLocalResolutionPinWriteNotAborted(signal) {
+	return Result.try({
+		try: () => signal?.throwIfAborted(),
+		catch: (cause) => new LocalResolutionPinWriteAbortedError(cause)
+	});
+}
+function serializeLocalResolutionPin(pin) {
+	return Result.try({
+		try: () => `${JSON.stringify(pin, null, 2)}\n`,
+		catch: (cause) => new LocalResolutionPinSerializationError(cause)
+	});
+}
+function writeLocalResolutionPinBoundary(run, operation, signal) {
+	return Result.tryPromise({
+		try: async () => {
+			await run();
+		},
+		catch: (cause) => signal?.aborted ? new LocalResolutionPinWriteAbortedError(cause) : new LocalResolutionPinWriteFailedError(operation, cause)
+	});
+}
+function ensureLocalResolutionPinGitignoreUpdateNotAborted(signal) {
+	return Result.try({
+		try: () => signal?.throwIfAborted(),
+		catch: (cause) => new LocalResolutionPinGitignoreUpdateAbortedError(cause)
+	});
+}
+function writeLocalResolutionPinGitignore(gitignorePath, contents, signal) {
+	return Result.tryPromise({
+		try: () => writeFile(gitignorePath, contents, {
 			encoding: "utf8",
 			signal
-		});
-		return;
-	}
-	if (existing.split(/\r?\n/).map((line) => line.trim()).some((line) => line === ".prisma/" || line === ".prisma/local.json")) return;
-	await writeFile(gitignorePath, existing.endsWith("\n") ? `${existing}.prisma/\n` : `${existing}\n.prisma/\n`, {
-		encoding: "utf8",
-		signal
+		}),
+		catch: (cause) => signal?.aborted ? new LocalResolutionPinGitignoreUpdateAbortedError(cause) : new LocalResolutionPinGitignoreUpdateFailedError("write", cause)
 	});
 }
 function isLocalResolutionPin(value) {