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

package/README.md

@@ -57,6 +57,8 @@ Useful next commands:
 npx prisma-cli app logs
 npx prisma-cli app open
 npx prisma-cli project env add DATABASE_URL=postgresql://example --role preview
+npx prisma-cli project env add --file .env --role preview
+npx prisma-cli project env list
 npx prisma-cli project env list --role preview
 ```
 
@@ -73,7 +75,7 @@ The beta package exposes `prisma-cli` so it can coexist with the existing
 | `auth` | Log in, log out, and inspect the active Prisma account. |
 | `project` | List projects, show the resolved project, and manage project environment variables. |
 | `git` | Connect or disconnect a project from a GitHub repository. |
-| `branch` | Inspect the Prisma branch that maps to the current work context. |
+| `branch` | List Prisma branches for the resolved project. |
 | `app` | Build, run, deploy, inspect, open, stream logs, promote, roll back, and remove apps. |
 
 Common examples:
@@ -82,7 +84,7 @@ Common examples:
 npx prisma-cli version
 npx prisma-cli auth whoami
 npx prisma-cli project show
-npx prisma-cli branch show
+npx prisma-cli branch list
 npx prisma-cli app deploy --branch feat-login --framework nextjs
 npx prisma-cli app promote <deployment-id>
 ```
@@ -96,11 +98,24 @@ npx prisma-cli app promote <deployment-id>
 - Stable command groups, flags, and error codes for scripts and agents.
 - Environment variable values are not printed back to the terminal.
 
+### Agent skills
+
+For agent-guided Next.js deploys, install the Prisma CLI skill cluster at the
+project level. Match the skill ref to the installed CLI version:
+
+```bash
+npx prisma-cli version
+pnpm dlx skills@latest add prisma/prisma-cli/skills#cli-v<cli-version> --all
+```
+
+The skills teach agents how to prepare a Next.js app, run `app deploy`, verify
+the result, and route CLI / Compute feedback to the right Prisma channel.
+
 ---
 
 ## Beta notes
 
-- Requires Node.js 20 or newer.
+- Requires Node.js 22.12 or newer.
 - This is a beta package and may change quickly.
 - Official beta releases publish as `@prisma/cli`.
 - The package binary is `prisma-cli`, not `prisma`, during beta.

package/dist/adapters/git.js

@@ -2,7 +2,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 //#region src/adapters/git.ts
 const execFileAsync = promisify(execFile);
-async function readGitOriginRemote(cwd) {
+async function readGitOriginRemote(cwd, signal) {
 	try {
 		const { stdout } = await execFileAsync("git", [
 			"config",
@@ -10,14 +10,19 @@ async function readGitOriginRemote(cwd) {
 			"remote.origin.url"
 		], {
 			cwd,
-			timeout: 5e3
+			timeout: 5e3,
+			signal
 		});
 		const remote = stdout.trim();
 		return remote.length > 0 ? remote : null;
-	} catch {
+	} catch (error) {
+		if (signal?.aborted || isAbortError(error)) throw error;
 		return null;
 	}
 }
+function isAbortError(error) {
+	return error instanceof Error && error.name === "AbortError";
+}
 function parseGitHubRepositoryUrl(value) {
 	const input = value.trim();
 	const shorthand = input.match(/^git@github\.com:([^/\s]+)\/([^/\s]+?)(?:\.git)?$/);

package/dist/adapters/local-state.js

@@ -20,12 +20,17 @@ function resolveLocalStateFilePath(stateDir) {
 }
 var LocalStateStore = class {
 	stateFilePath;
-	constructor(stateDir) {
+	constructor(stateDir, signal) {
+		this.signal = signal;
 		this.stateFilePath = resolveLocalStateFilePath(stateDir);
 	}
 	async read() {
+		this.signal?.throwIfAborted();
 		try {
-			const raw = await readFile(this.stateFilePath, "utf8");
+			const raw = await readFile(this.stateFilePath, {
+				encoding: "utf8",
+				signal: this.signal
+			});
 			const parsed = JSON.parse(raw);
 			return {
 				auth: parsed.auth ?? structuredClone(DEFAULT_STATE.auth),
@@ -46,8 +51,11 @@ var LocalStateStore = class {
 		}
 	}
 	async write(state) {
+		this.signal?.throwIfAborted();
 		await mkdir(path.dirname(this.stateFilePath), { recursive: true });
-		await writeFile(this.stateFilePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+		this.signal?.throwIfAborted();
+		await writeFile(this.stateFilePath, `${JSON.stringify(state, null, 2)}\n`, { encoding: "utf8" });
+		this.signal?.throwIfAborted();
 	}
 	async setAuthSession(session) {
 		const state = await this.read();
@@ -133,4 +141,4 @@ var LocalStateStore = class {
 	}
 };
 //#endregion
-export { LocalStateStore };
+export { LocalStateStore, resolveLocalStateFilePath };

package/dist/adapters/mock-api.js

@@ -5,8 +5,12 @@ var MockApi = class MockApi {
 	constructor(data) {
 		this.data = data;
 	}
-	static async load(fixturePath) {
-		const raw = await readFile(fixturePath, "utf8");
+	static async load(fixturePath, signal) {
+		signal?.throwIfAborted();
+		const raw = await readFile(fixturePath, {
+			encoding: "utf8",
+			signal
+		});
 		return new MockApi(JSON.parse(raw));
 	}
 	listProviders() {
@@ -52,6 +56,81 @@ var MockApi = class MockApi {
 	getDeployment(deploymentId) {
 		return this.data.deployments.find((deployment) => deployment.id === deploymentId);
 	}
+	listDatabasesForProject(projectId, branchName) {
+		return (this.data.databases ?? []).filter((database) => database.projectId === projectId && (!branchName || database.branchName === branchName));
+	}
+	getDatabase(databaseId) {
+		return (this.data.databases ?? []).find((database) => database.id === databaseId);
+	}
+	createDatabase(input) {
+		this.data.databases ??= [];
+		this.data.databaseConnections ??= [];
+		const database = {
+			id: `db_${this.data.databases.length + 1e3}`,
+			projectId: input.projectId,
+			branchId: input.branchName ? this.getBranchForProject(input.projectId, input.branchName)?.id ?? null : null,
+			branchName: input.branchName ?? null,
+			name: input.name,
+			region: input.region ?? null,
+			status: "ready",
+			isDefault: false,
+			createdAt: "2026-06-09T00:00:00.000Z"
+		};
+		const connectionString = `postgresql://${database.id}.example.prisma.io/postgres`;
+		const connection = {
+			id: `conn_${this.data.databaseConnections.length + 1e3}`,
+			databaseId: database.id,
+			name: "primary",
+			createdAt: "2026-06-09T00:00:00.000Z",
+			connectionString
+		};
+		this.data.databases.push(database);
+		this.data.databaseConnections.push(connection);
+		return {
+			database,
+			connection,
+			connectionString
+		};
+	}
+	removeDatabase(databaseId) {
+		this.data.databases ??= [];
+		this.data.databaseConnections ??= [];
+		const database = this.getDatabase(databaseId);
+		if (!database) return;
+		this.data.databases = this.data.databases.filter((candidate) => candidate.id !== databaseId);
+		this.data.databaseConnections = this.data.databaseConnections.filter((connection) => connection.databaseId !== databaseId);
+		return database;
+	}
+	listDatabaseConnections(databaseId) {
+		return (this.data.databaseConnections ?? []).filter((connection) => connection.databaseId === databaseId);
+	}
+	getDatabaseConnection(connectionId) {
+		return (this.data.databaseConnections ?? []).find((connection) => connection.id === connectionId);
+	}
+	createDatabaseConnection(input) {
+		if (!this.getDatabase(input.databaseId)) return;
+		this.data.databaseConnections ??= [];
+		const connectionString = `postgresql://${input.databaseId}-${this.data.databaseConnections.length + 1}.example.prisma.io/postgres`;
+		const connection = {
+			id: `conn_${this.data.databaseConnections.length + 1e3}`,
+			databaseId: input.databaseId,
+			name: input.name,
+			createdAt: "2026-06-09T00:00:00.000Z",
+			connectionString
+		};
+		this.data.databaseConnections.push(connection);
+		return {
+			connection,
+			connectionString
+		};
+	}
+	removeDatabaseConnection(connectionId) {
+		this.data.databaseConnections ??= [];
+		const connection = this.getDatabaseConnection(connectionId);
+		if (!connection) return;
+		this.data.databaseConnections = this.data.databaseConnections.filter((candidate) => candidate.id !== connectionId);
+		return connection;
+	}
 };
 //#endregion
 export { MockApi };

package/dist/adapters/token-storage.js

@@ -20,37 +20,60 @@ function findLatestValidTokens(allCredentials) {
 function tokensEqual(a, b) {
 	return a?.workspaceId === b?.workspaceId && a?.accessToken === b?.accessToken && a?.refreshToken === b?.refreshToken;
 }
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
+function sleep(ms, signal) {
+	signal?.throwIfAborted();
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timeout);
+			reject(signal?.reason);
+		};
+		const timeout = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
 }
 var FileTokenStorage = class {
 	credentialsStore;
 	lockFilePath;
-	constructor(env = process.env) {
+	constructor(env = process.env, signal) {
+		this.signal = signal;
 		const authFilePath = getAuthFilePath(env);
 		this.credentialsStore = new CredentialsStore(authFilePath);
 		this.lockFilePath = `${authFilePath}.lock`;
 	}
 	async getTokens() {
+		this.signal?.throwIfAborted();
 		try {
-			return findLatestValidTokens(await this.credentialsStore.getCredentials());
-		} catch {
+			const all = await this.credentialsStore.getCredentials();
+			this.signal?.throwIfAborted();
+			return findLatestValidTokens(all);
+		} catch (error) {
+			if (this.signal?.aborted) throw this.signal.reason;
 			return null;
 		}
 	}
 	async setTokens(tokens) {
+		this.signal?.throwIfAborted();
 		await this.credentialsStore.storeCredentials({
 			workspaceId: tokens.workspaceId,
 			token: tokens.accessToken,
 			refreshToken: tokens.refreshToken
 		});
+		this.signal?.throwIfAborted();
 	}
 	async clearTokens() {
-		const tokens = findLatestValidTokens(await this.credentialsStore.getCredentials());
+		this.signal?.throwIfAborted();
+		const all = await this.credentialsStore.getCredentials();
+		this.signal?.throwIfAborted();
+		const tokens = findLatestValidTokens(all);
 		if (!tokens) return;
 		await this.credentialsStore.deleteCredentials(tokens.workspaceId);
+		this.signal?.throwIfAborted();
 	}
 	async clearTokensIfCurrent(tokens) {
+		this.signal?.throwIfAborted();
 		if (!tokensEqual(await this.getTokens(), tokens)) return;
 		await this.clearTokens();
 	}
@@ -64,34 +87,52 @@ var FileTokenStorage = class {
 	}
 	async acquireRefreshLock() {
 		const lockId = randomUUID();
+		this.signal?.throwIfAborted();
 		await fs.mkdir(path.dirname(this.lockFilePath), { recursive: true });
-		while (true) try {
-			const handle = await fs.open(this.lockFilePath, "wx");
+		while (true) {
+			this.signal?.throwIfAborted();
+			let lockFileCreated = false;
 			try {
-				await handle.writeFile(lockId, "utf8");
-			} finally {
-				await handle.close();
-			}
-			return lockId;
-		} catch (error) {
-			if (error.code !== "EEXIST") throw error;
-			const staleLockId = await this.getStaleRefreshLockId();
-			if (staleLockId) {
-				await this.releaseRefreshLock(staleLockId);
-				continue;
+				const handle = await fs.open(this.lockFilePath, "wx");
+				lockFileCreated = true;
+				try {
+					this.signal?.throwIfAborted();
+					await handle.writeFile(lockId, { encoding: "utf8" });
+					this.signal?.throwIfAborted();
+				} finally {
+					await handle.close();
+				}
+				return lockId;
+			} catch (error) {
+				if (lockFileCreated) await fs.unlink(this.lockFilePath).catch(() => void 0);
+				if (error.code !== "EEXIST") throw error;
+				const staleLockId = await this.getStaleRefreshLockId();
+				if (staleLockId) {
+					await this.releaseRefreshLock(staleLockId);
+					continue;
+				}
+				await sleep(100, this.signal);
 			}
-			await sleep(100);
 		}
 	}
 	async getStaleRefreshLockId() {
-		const lockId = await fs.readFile(this.lockFilePath, "utf8").catch(() => null);
+		this.signal?.throwIfAborted();
+		const lockId = await fs.readFile(this.lockFilePath, {
+			encoding: "utf8",
+			signal: this.signal
+		}).catch((error) => {
+			if (this.signal?.aborted) throw error;
+			return null;
+		});
 		if (lockId === null) return null;
+		this.signal?.throwIfAborted();
 		const stats = await fs.stat(this.lockFilePath).catch(() => null);
+		this.signal?.throwIfAborted();
 		if (!stats) return null;
 		return Date.now() - stats.mtimeMs > 3e4 ? lockId : null;
 	}
 	async releaseRefreshLock(lockId) {
-		if (await fs.readFile(this.lockFilePath, "utf8").catch(() => null) !== lockId) return;
+		if (await fs.readFile(this.lockFilePath, { encoding: "utf8" }).catch(() => null) !== lockId) return;
 		await fs.unlink(this.lockFilePath).catch(() => {});
 	}
 };

package/dist/cli.js

@@ -1,9 +1,24 @@
 #!/usr/bin/env node
+import { runUpdateDiscoveryWorker } from "./shell/update-check.js";
 import { runCli } from "./cli2.js";
 import process from "node:process";
 //#region src/bin.ts
-runCli().then((exitCode) => {
-	process.exitCode = exitCode;
+if (process.env.PRISMA_CLI_RUN_UPDATE_CHECK_WORKER === "1") runUpdateDiscoveryWorker().then(() => {
+	process.exitCode = 0;
 });
+else {
+	const controller = new AbortController();
+	const abortCli = () => {
+		if (!controller.signal.aborted) controller.abort(new DOMException("Command canceled", "AbortError"));
+	};
+	process.once("SIGINT", abortCli);
+	process.once("SIGTERM", abortCli);
+	runCli({ signal: controller.signal }).then((exitCode) => {
+		process.exitCode = exitCode;
+	}).finally(() => {
+		process.off("SIGINT", abortCli);
+		process.off("SIGTERM", abortCli);
+	});
+}
 //#endregion
 export {};

package/dist/cli2.js

@@ -1,6 +1,6 @@
 import { CliError } from "./shell/errors.js";
 import { createShellUi } from "./shell/ui.js";
-import { writeHumanError, writeJsonError, writeJsonSuccess } from "./shell/output.js";
+import { formatUnexpectedError, writeHumanError, writeJsonError, writeJsonSuccess } from "./shell/output.js";
 import { attachCommandDescriptor } from "./shell/command-meta.js";
 import { addCompactGlobalFlags } from "./shell/global-flags.js";
 import { configureRuntimeCommand, createCommandContext } from "./shell/runtime.js";
@@ -8,11 +8,13 @@ import "./shell/prompt.js";
 import { createAppCommand } from "./commands/app/index.js";
 import { createAuthCommand } from "./commands/auth/index.js";
 import { createBranchCommand } from "./commands/branch/index.js";
+import { createDatabaseCommand } from "./commands/database/index.js";
 import { createGitCommand } from "./commands/git/index.js";
 import { createProjectCommand } from "./commands/project/index.js";
 import { getCliName, getCliVersion } from "./lib/version.js";
 import { runVersion } from "./controllers/version.js";
 import { createVersionCommand } from "./commands/version/index.js";
+import { maybeWriteCachedUpdateNotification } from "./shell/update-check.js";
 import process from "node:process";
 import { Command, CommanderError, Option } from "commander";
 //#region src/cli.ts
@@ -21,6 +23,7 @@ async function runCli(options = {}) {
 	const program = createProgram(runtime);
 	process.exitCode = 0;
 	try {
+		await maybeWriteCachedUpdateNotification(runtime);
 		if (runtime.argv.includes("--version")) return await handleVersionFlag(runtime);
 		const bareHelpCommand = resolveBareHelpCommand(program, runtime.argv);
 		if (bareHelpCommand) {
@@ -31,8 +34,7 @@ async function runCli(options = {}) {
 		return process.exitCode ?? 0;
 	} catch (error) {
 		if (error instanceof CommanderError) return error.code === "commander.helpDisplayed" ? 0 : 2;
-		const message = error instanceof Error ? error.stack ?? error.message : String(error);
-		runtime.stderr.write(`${message}\n`);
+		runtime.stderr.write(formatUnexpectedError(error, runtime.argv.includes("--trace")));
 		return 1;
 	} finally {
 		runtime.stdin;
@@ -48,6 +50,7 @@ function createProgram(runtime) {
 	program.addCommand(createProjectCommand(runtime));
 	program.addCommand(createGitCommand(runtime));
 	program.addCommand(createBranchCommand(runtime));
+	program.addCommand(createDatabaseCommand(runtime));
 	program.addCommand(createAppCommand(runtime));
 	return program;
 }
@@ -104,6 +107,7 @@ function resolveRuntime(options) {
 		argv: options.argv ?? process.argv.slice(2),
 		cwd: options.cwd ?? process.env.INIT_CWD ?? process.cwd(),
 		env: options.env ?? process.env,
+		signal: options.signal ?? new AbortController().signal,
 		stdin: options.stdin ?? process.stdin,
 		stdout: options.stdout ?? process.stdout,
 		stderr: options.stderr ?? process.stderr,

package/dist/commands/app/index.js

@@ -1,3 +1,4 @@
+import { usageError } from "../../shell/errors.js";
 import { attachCommandDescriptor } from "../../shell/command-meta.js";
 import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
@@ -59,36 +60,48 @@ function createRunCommand(runtime) {
 }
 function createDeployCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("deploy"), runtime), "app.deploy");
-	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--branch <name>", "Branch name")).addOption(new Option("--framework <name>", "Framework to deploy").choices([
+	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--create-project <name>", "Create and link a new Project before deploying")).addOption(new Option("--branch <name>", "Branch name")).addOption(new Option("--framework <name>", "Framework to deploy").choices([
 		"nextjs",
 		"hono",
-		"tanstack-start"
-	])).addOption(new Option("--entry <path>", "Entrypoint path for Bun or auto deploys")).addOption(new Option("--build-type <type>", "Legacy deploy build type").choices([...PREVIEW_BUILD_TYPES]).default("auto").hideHelp()).addOption(new Option("--http-port <port>", "HTTP port override for the deployed app")).addOption(new Option("--env <name=value>", "Environment variable").argParser(collectRepeatableValues));
+		"tanstack-start",
+		"bun"
+	])).addOption(new Option("--entry <path>", "Entrypoint path for Bun deploys")).addOption(new Option("--http-port <port>", "HTTP port override for the deployed app")).addOption(new Option("--env <name=value|file>", "Environment variable assignment or dotenv file").argParser(collectRepeatableValues)).addOption(new Option("--db", "Create and wire a Prisma Postgres database for this deploy target")).addOption(new Option("--no-db", "Skip database setup")).addOption(new Option("--prod", "Confirm intent to deploy to production"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
 		const entry = options.entry;
-		const buildType = options.buildType;
 		const branchName = options.branch;
 		const framework = options.framework;
 		const httpPort = options.httpPort;
 		const envAssignments = options.env;
 		const projectRef = options.project;
-		await runCommand(runtime, "app.deploy", options, (context) => runAppDeploy(context, appName, {
-			projectRef,
-			branchName,
-			entrypoint: entry,
-			buildType,
-			framework,
-			httpPort,
-			envAssignments
-		}), {
+		const createProjectName = options.createProject;
+		const prod = options.prod;
+		const db = options.db;
+		const hasDbConflict = hasFlag(runtime.argv, "--db") && hasFlag(runtime.argv, "--no-db");
+		await runCommand(runtime, "app.deploy", options, (context) => {
+			if (hasDbConflict) throw usageError("app deploy accepts either --db or --no-db", "--db requests database setup, while --no-db disables it.", "Pass exactly one database setup flag.", ["prisma-cli app deploy --db", "prisma-cli app deploy --no-db"], "app");
+			return runAppDeploy(context, appName, {
+				projectRef,
+				createProjectName,
+				branchName,
+				entrypoint: entry,
+				framework,
+				httpPort,
+				envAssignments,
+				prod: prod === true,
+				db
+			});
+		}, {
 			renderHuman: (context, descriptor, result) => renderAppDeploy(context, descriptor, result),
 			renderJson: (result) => serializeAppDeploy(result)
 		});
 	});
 	return command;
 }
+function hasFlag(argv, flag) {
+	return argv.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+}
 function createShowCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "app.show");
 	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));

package/dist/commands/branch/index.js

@@ -2,16 +2,14 @@ import { attachCommandDescriptor } from "../../shell/command-meta.js";
 import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
 import { runCommand } from "../../shell/command-runner.js";
-import { runBranchList, runBranchShow, runBranchUse } from "../../controllers/branch.js";
-import { renderBranchList, renderBranchShow, renderBranchUse, serializeBranchList, serializeBranchShow } from "../../presenters/branch.js";
+import { runBranchList } from "../../controllers/branch.js";
+import { renderBranchList, serializeBranchList } from "../../presenters/branch.js";
 import { Command } from "commander";
 //#region src/commands/branch/index.ts
 function createBranchCommand(runtime) {
 	const branch = attachCommandDescriptor(configureRuntimeCommand(new Command("branch"), runtime), "branch");
 	addCompactGlobalFlags(branch);
 	branch.addCommand(createBranchListCommand(runtime));
-	branch.addCommand(createBranchShowCommand(runtime));
-	branch.addCommand(createBranchUseCommand(runtime));
 	return branch;
 }
 function createBranchListCommand(runtime) {
@@ -25,28 +23,5 @@ function createBranchListCommand(runtime) {
 	});
 	return command;
 }
-function createBranchShowCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "branch.show");
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "branch.show", options, (context) => runBranchShow(context), {
-			renderHuman: (context, descriptor, result) => renderBranchShow(context, descriptor, result),
-			renderJson: (result) => serializeBranchShow(result)
-		});
-	});
-	return command;
-}
-function createBranchUseCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("use"), runtime), "branch.use");
-	command.argument("[name]", "Branch name");
-	addGlobalFlags(command);
-	command.action(async (branchName, options) => {
-		await runCommand(runtime, "branch.use", options, (context) => runBranchUse(context, branchName), {
-			renderHuman: (context, descriptor, result) => renderBranchUse(context, descriptor, result),
-			renderJson: (result) => serializeBranchShow(result)
-		});
-	});
-	return command;
-}
 //#endregion
 export { createBranchCommand };