@prisma/cli 3.0.0-beta.2 → 3.0.0-beta.4

package/dist/lib/auth/login.js

@@ -4,6 +4,7 @@ import open from "open";
 import { AuthError, createManagementApiSdk } from "@prisma/management-api-sdk";
 import events from "node:events";
 import http from "node:http";
+import readline from "node:readline/promises";
 //#region src/lib/auth/login.ts
 var AuthError$1 = class extends Error {
 	constructor(message) {
@@ -14,11 +15,15 @@ var AuthError$1 = class extends Error {
 async function login(options = {}) {
 	const hostname = options.hostname ?? "localhost";
 	const port = options.port ?? 0;
+	const input = options.input ?? process.stdin;
+	const output = options.output ?? process.stderr;
+	const interactive = input.isTTY === true;
 	const server = http.createServer();
 	server.listen({
 		host: hostname,
 		port
 	});
+	const pasteAbort = new AbortController();
 	try {
 		const state = new LoginState({
 			hostname,
@@ -28,9 +33,30 @@ async function login(options = {}) {
 			apiBaseUrl: options.apiBaseUrl,
 			authBaseUrl: options.authBaseUrl,
 			openUrl: options.openUrl,
-			env: options.env
+			env: options.env,
+			signal: options.signal,
+			output
 		});
-		const authResult = new Promise((resolve, reject) => {
+		let completed = false;
+		let completion;
+		const completeOnce = (url) => {
+			if (!completion) completion = state.handleCallback(url).then(() => {
+				completed = true;
+			}, (error) => {
+				completion = void 0;
+				throw error;
+			});
+			return completion;
+		};
+		const httpResult = new Promise((resolve, reject) => {
+			const onAbort = () => {
+				reject(options.signal?.reason);
+			};
+			options.signal?.addEventListener("abort", onAbort, { once: true });
+			const settle = (callback) => {
+				options.signal?.removeEventListener("abort", onAbort);
+				callback();
+			};
 			server.on("request", async (req, res) => {
 				const url = new URL(`http://${state.host}${req.url}`);
 				if (url.pathname !== "/auth/callback") {
@@ -38,36 +64,87 @@ async function login(options = {}) {
 					res.end("Not found");
 					return;
 				}
+				if (completed) {
+					const workspaceName = await state.resolveWorkspaceName();
+					res.setHeader("Content-Type", "text/html; charset=utf-8");
+					res.end(renderSuccessPage(workspaceName));
+					return;
+				}
 				try {
-					await state.handleCallback(url);
+					await completeOnce(url);
+					const workspaceName = await state.resolveWorkspaceName();
+					res.setHeader("Content-Type", "text/html; charset=utf-8");
+					res.end(renderSuccessPage(workspaceName));
+					settle(resolve);
 				} catch (error) {
 					res.statusCode = 400;
 					const message = error instanceof Error ? error.message : String(error);
 					res.end(message);
-					reject(error);
+					settle(() => reject(error));
 					return;
 				}
-				const workspaceName = await state.resolveWorkspaceName();
-				res.setHeader("Content-Type", "text/html; charset=utf-8");
-				res.end(renderSuccessPage(workspaceName));
-				resolve();
 			});
 		});
-		await state.openLoginPage();
-		await authResult;
+		options.signal?.throwIfAborted();
+		const callbackResult = interactive ? Promise.race([httpResult, consumePastedCallback({
+			input,
+			output,
+			signal: pasteAbort.signal,
+			complete: completeOnce
+		})]) : httpResult;
+		await Promise.all([state.openLoginPage(interactive), callbackResult]);
 	} finally {
+		pasteAbort.abort();
 		if (server.listening) await new Promise((resolve) => server.close(() => resolve()));
 	}
 }
+async function consumePastedCallback(options) {
+	if (!options.input.isTTY) return;
+	const rl = readline.createInterface({
+		input: options.input,
+		output: options.output
+	});
+	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;
+			}
+		}
+	} finally {
+		rl.close();
+	}
+}
 var LoginState = class {
 	latestVerifier;
 	latestState;
 	sdk;
 	openUrl;
 	tokenStorage;
+	output;
 	constructor(options) {
 		this.options = options;
-		this.tokenStorage = options.tokenStorage ?? new FileTokenStorage(options.env);
+		this.tokenStorage = options.tokenStorage ?? new FileTokenStorage(options.env, options.signal);
 		this.sdk = createManagementApiSdk({
 			clientId: options.clientId ?? "cmm3lndn701oo0uefvxzo0ivw",
 			redirectUri: `http://${options.hostname}:${options.port}/auth/callback`,
@@ -76,8 +153,10 @@ var LoginState = class {
 			authBaseUrl: options.authBaseUrl
 		});
 		this.openUrl = options.openUrl ?? open;
+		this.output = options.output;
 	}
-	async openLoginPage() {
+	async openLoginPage(interactive) {
+		this.options.signal?.throwIfAborted();
 		const { url, state, verifier } = await this.sdk.getLoginUrl({
 			scope: "workspace:admin offline_access",
 			additionalParams: {
@@ -88,7 +167,19 @@ var LoginState = class {
 		});
 		this.latestState = state;
 		this.latestVerifier = verifier;
-		await this.openUrl(url);
+		this.options.signal?.throwIfAborted();
+		if (interactive) this.printLoginInstructions(url);
+		try {
+			await this.openUrl(url);
+		} catch (error) {
+			if (!interactive) throw error;
+		}
+		this.options.signal?.throwIfAborted();
+	}
+	printLoginInstructions(url) {
+		const output = this.output;
+		if (!output) return;
+		output.write(`\nOpen this URL to sign in: ${url}\n\nIf the browser opens on another machine, finish sign-in there. When it\nredirects to localhost, copy the full localhost URL from the address bar\nand paste it here.\n\n`);
 	}
 	async handleCallback(url) {
 		if (url.pathname !== "/auth/callback") throw new AuthError$1("Not a callback URL");
@@ -115,10 +206,14 @@ var LoginState = class {
 		try {
 			const tokens = await this.tokenStorage.getTokens();
 			if (!tokens?.workspaceId) return null;
-			const { data } = await this.sdk.client.GET("/v1/workspaces/{id}", { params: { path: { id: tokens.workspaceId } } });
+			const { data } = await this.sdk.client.GET("/v1/workspaces/{id}", {
+				params: { path: { id: tokens.workspaceId } },
+				signal: this.options.signal
+			});
 			const name = data?.data?.name;
 			return typeof name === "string" && name.trim().length > 0 ? name.trim() : null;
 		} catch {
+			this.options.signal?.throwIfAborted();
 			return null;
 		}
 	}

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

@@ -0,0 +1,41 @@
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+//#region src/lib/git/local-branch.ts
+async function readLocalGitBranch(cwd, signal) {
+	const headPath = await resolveGitHeadPath(path.join(cwd, ".git"), signal);
+	if (!headPath) return null;
+	try {
+		const head = (await readFile(headPath, {
+			encoding: "utf8",
+			signal
+		})).trim();
+		if (head.startsWith("ref: refs/heads/")) return head.slice(16);
+	} catch (error) {
+		if (signal.aborted) throw error;
+		return null;
+	}
+	return null;
+}
+async function resolveGitHeadPath(gitPath, signal) {
+	signal.throwIfAborted();
+	try {
+		const raw = await readFile(gitPath, {
+			encoding: "utf8",
+			signal
+		});
+		if (raw.startsWith("gitdir:")) return path.join(path.resolve(path.dirname(gitPath), raw.slice(7).trim()), "HEAD");
+	} catch (error) {
+		if (signal.aborted) throw error;
+	}
+	signal.throwIfAborted();
+	try {
+		await access(path.join(gitPath, "HEAD"));
+		signal.throwIfAborted();
+		return path.join(gitPath, "HEAD");
+	} catch (error) {
+		if (signal.aborted) throw error;
+		return null;
+	}
+}
+//#endregion
+export { readLocalGitBranch };

package/dist/lib/project/interactive-setup.js

@@ -36,7 +36,7 @@ async function promptForProjectSetupChoice(options) {
 		targetName: choice.project.name,
 		targetNameSource: "prompt"
 	};
-	const suggestedName = await inferTargetName(options.context.runtime.cwd);
+	const suggestedName = await inferTargetName(options.context.runtime.cwd, options.context.runtime.signal);
 	const rawName = await textPrompt({
 		input: options.context.runtime.stdin,
 		output: options.context.runtime.stderr,

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

@@ -2,9 +2,13 @@ import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
 //#region src/lib/project/local-pin.ts
 const LOCAL_RESOLUTION_PIN_RELATIVE_PATH = ".prisma/local.json";
-async function readLocalResolutionPin(cwd) {
+async function readLocalResolutionPin(cwd, signal) {
+	signal?.throwIfAborted();
 	try {
-		const raw = await readFile(path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH), "utf8");
+		const raw = await readFile(path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH), {
+			encoding: "utf8",
+			signal
+		});
 		const parsed = JSON.parse(raw);
 		if (!isLocalResolutionPin(parsed)) return { kind: "invalid" };
 		return {
@@ -17,28 +21,43 @@ async function readLocalResolutionPin(cwd) {
 		throw error;
 	}
 }
-async function writeLocalResolutionPin(cwd, pin) {
+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`, "utf8");
+	await writeFile(tmpPath, `${JSON.stringify(pin, null, 2)}\n`, {
+		encoding: "utf8",
+		signal
+	});
+	signal?.throwIfAborted();
 	await rename(tmpPath, pinPath);
 }
-async function ensureLocalResolutionPinGitignore(cwd) {
+async function ensureLocalResolutionPinGitignore(cwd, signal) {
 	const gitignorePath = path.join(cwd, ".gitignore");
 	let existing = null;
+	signal?.throwIfAborted();
 	try {
-		existing = await readFile(gitignorePath, "utf8");
+		existing = await readFile(gitignorePath, {
+			encoding: "utf8",
+			signal
+		});
 	} catch (error) {
 		if (error.code !== "ENOENT") throw error;
 	}
 	if (existing === null) {
-		await writeFile(gitignorePath, ".prisma/\n", "utf8");
+		await writeFile(gitignorePath, ".prisma/\n", {
+			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`, "utf8");
+	await writeFile(gitignorePath, existing.endsWith("\n") ? `${existing}.prisma/\n` : `${existing}\n.prisma/\n`, {
+		encoding: "utf8",
+		signal
+	});
 }
 function isLocalResolutionPin(value) {
 	if (!value || typeof value !== "object") return false;

package/dist/lib/project/resolution.js

@@ -11,7 +11,8 @@ async function resolveProjectTarget(options) {
 	throw await projectSetupRequiredError({
 		cwd: options.context.runtime.cwd,
 		projects,
-		commandName: options.commandName
+		commandName: options.commandName,
+		signal: options.context.runtime.signal
 	});
 }
 async function inspectProjectBinding(options) {
@@ -26,7 +27,8 @@ async function inspectProjectBinding(options) {
 		...await buildProjectSetupSuggestion({
 			cwd: options.context.runtime.cwd,
 			projects,
-			commandName: options.commandName ?? "project show"
+			commandName: options.commandName ?? "project show",
+			signal: options.context.runtime.signal
 		})
 	};
 }
@@ -72,7 +74,7 @@ function localStateStaleError() {
 	});
 }
 async function buildProjectSetupSuggestion(options) {
-	const suggestedName = await inferTargetName(options.cwd);
+	const suggestedName = await inferTargetName(options.cwd, options.signal);
 	const candidates = sortProjects(options.projects.filter((project) => projectMatchesSuggestedName(project, suggestedName.name))).map(toProjectSummary);
 	return {
 		suggestedProjectName: suggestedName.name,
@@ -131,9 +133,13 @@ function buildProjectSetupNextActions(options = {}) {
 	});
 	return actions;
 }
-async function readPackageName(cwd) {
+async function readPackageName(cwd, signal) {
+	signal?.throwIfAborted();
 	try {
-		const raw = await readFile(path.join(cwd, "package.json"), "utf8");
+		const raw = await readFile(path.join(cwd, "package.json"), {
+			encoding: "utf8",
+			signal
+		});
 		const parsed = JSON.parse(raw);
 		if (!parsed || typeof parsed !== "object") return null;
 		const packageName = "name" in parsed ? parsed.name : null;
@@ -144,8 +150,8 @@ async function readPackageName(cwd) {
 		throw error;
 	}
 }
-async function inferTargetName(cwd) {
-	const packageName = await readPackageName(cwd);
+async function inferTargetName(cwd, signal) {
+	const packageName = await readPackageName(cwd, signal);
 	if (packageName && isValidInferredTargetName(packageName)) return {
 		name: packageName,
 		source: "package-name"
@@ -186,7 +192,7 @@ async function resolveBoundProjectTarget(options, projects, settings) {
 			targetNameSource: "env"
 		});
 	}
-	const localPin = await readLocalResolutionPin(options.context.runtime.cwd);
+	const localPin = await readLocalResolutionPin(options.context.runtime.cwd, options.context.runtime.signal);
 	if (localPin.kind === "invalid") throw localStateStaleError();
 	if (localPin.kind === "present") {
 		if (localPin.pin.workspaceId !== options.workspace.id) throw localStateStaleError();

package/dist/lib/project/setup.js

@@ -20,8 +20,8 @@ async function bindProjectToDirectory(context, workspace, project, action) {
 	await writeLocalResolutionPin(context.runtime.cwd, {
 		workspaceId: workspace.id,
 		projectId: project.id
-	});
-	await ensureLocalResolutionPinGitignore(context.runtime.cwd);
+	}, context.runtime.signal);
+	await ensureLocalResolutionPinGitignore(context.runtime.cwd, context.runtime.signal);
 	return {
 		workspace,
 		project,

package/dist/presenters/app-env.js

@@ -2,8 +2,18 @@ import { renderList, renderShow, serializeList } from "../output/patterns.js";
 //#region src/presenters/app-env.ts
 function scopeLabel(scope) {
 	if (scope.kind === "role") return scope.role ?? "unknown";
+	if (scope.kind === "overview") return "overview";
 	return `branch:${scope.branchName ?? scope.branchId ?? "unknown"}`;
 }
+function listTargetLabel(result) {
+	const target = result.target;
+	if (target.source === "overview") return "overview";
+	if (target.branchName) {
+		const suffix = target.branchExists === false ? " (not created yet)" : "";
+		return `branch:${target.branchName} -> ${target.envMap}${suffix}`;
+	}
+	return scopeLabel(result.scope);
+}
 function renderEnvAdd(context, descriptor, result) {
 	return renderShow({
 		title: "Setting a new environment variable.",
@@ -75,8 +85,8 @@ function renderEnvList(context, descriptor, result) {
 		title: "Listing environment variables for the selected scope.",
 		descriptor,
 		parentContext: {
-			key: "scope",
-			value: scopeLabel(result.scope)
+			key: "target",
+			value: listTargetLabel(result)
 		},
 		items: result.variables.map((variable) => ({
 			noun: "variable",
@@ -91,8 +101,9 @@ function serializeEnvList(result) {
 	return {
 		projectId: result.projectId,
 		scope: result.scope,
+		target: result.target,
 		...serializeList({
-			context: { scope: scopeLabel(result.scope) },
+			context: { target: listTargetLabel(result) },
 			items: result.variables.map((variable) => ({
 				noun: "variable",
 				label: `${variable.key} (${variable.source})`,

package/dist/presenters/branch.js

@@ -1,111 +1,39 @@
-import { renderList, renderMutate, renderShow, serializeList } from "../output/patterns.js";
+import { formatColumns } from "../shell/ui.js";
+import { formatDescriptorLabel } from "../shell/command-meta.js";
 //#region src/presenters/branch.ts
 function renderBranchList(context, descriptor, result) {
-	return renderList({
-		title: "Listing branches for the resolved project.",
-		descriptor,
-		parentContext: {
-			key: "project",
-			value: result.projectName ?? "not resolved"
-		},
-		items: result.branches.map((branch) => ({
-			noun: "branch",
-			label: branch.name,
-			id: branch.id,
-			status: branch.active ? "active" : null
-		})),
-		emptyMessage: "No branches found."
-	}, context.ui);
+	const ui = context.ui;
+	const lines = [`${ui.strong(formatDescriptorLabel(descriptor))} ${ui.dim("→")} ${ui.dim("Listing branches for the resolved project.")}`, ""];
+	const rail = ui.dim("│");
+	lines.push(`${rail}  ${ui.accent("project:")}  ${result.projectName}`);
+	lines.push(rail);
+	if (result.branches.length === 0) {
+		lines.push(`${rail}  ${ui.dim("No branches found.")}`);
+		return lines;
+	}
+	const widths = [
+		Math.max(4, ...result.branches.map((branch) => branch.name.length)),
+		Math.max(4, ...result.branches.map((branch) => branch.role.length)),
+		Math.max(7, ...result.branches.map((branch) => branch.envMap.length))
+	];
+	lines.push(`${rail}  ${ui.accent(formatColumns([
+		"Name",
+		"Role",
+		"Env map"
+	], widths))}`);
+	for (const branch of result.branches) lines.push(`${rail}  ${formatColumns([
+		branch.name,
+		branch.role,
+		branch.envMap
+	], widths)}`);
+	return lines;
 }
 function serializeBranchList(result) {
-	return serializeList({
-		context: { project: result.projectName ?? "not resolved" },
-		items: result.branches.map((branch) => ({
-			noun: "branch",
-			label: branch.name,
-			id: branch.id,
-			status: branch.active ? "active" : null
-		}))
-	});
-}
-function serializeBranchShow(result) {
 	return {
 		projectId: result.projectId,
 		projectName: result.projectName,
-		branch: {
-			name: result.branch.name,
-			kind: result.branch.kind,
-			active: result.branch.active,
-			remoteState: result.branch.remoteState,
-			liveDeployment: result.branch.liveDeployment
-		}
+		branches: result.branches
 	};
 }
-function renderBranchShow(context, descriptor, result) {
-	const fields = [
-		{
-			key: "project",
-			value: result.projectName ?? "not resolved",
-			tone: result.projectName ? "default" : "dim"
-		},
-		{
-			key: "branch",
-			value: result.branch.name,
-			tone: result.branch.active ? "success" : "default"
-		},
-		{
-			key: "kind",
-			value: result.branch.kind
-		}
-	];
-	if (result.branch.liveDeployment) {
-		fields.push({
-			key: "status",
-			value: result.branch.liveDeployment.status,
-			tone: toneForDeploymentStatus(result.branch.liveDeployment.status)
-		});
-		if (result.branch.liveDeployment.url) fields.push({
-			key: "url",
-			value: result.branch.liveDeployment.url,
-			tone: "link"
-		});
-	} else if (!result.branch.remoteState) fields.push({
-		key: "remote state",
-		value: "not created yet",
-		tone: "dim"
-	});
-	return renderShow({
-		title: "Showing the current active branch context.",
-		descriptor,
-		fields
-	}, context.ui);
-}
-function toneForDeploymentStatus(status) {
-	if (status === "ready" || status === "active" || status === "healthy") return "success";
-	if (status === "pending" || status === "building" || status === "starting") return "warning";
-	if (status === "failed" || status === "error") return "error";
-	return "default";
-}
-function renderBranchUse(context, descriptor, result) {
-	return renderMutate({
-		title: "Changing the local default branch context.",
-		descriptor,
-		context: [{
-			key: "project",
-			value: result.projectName ?? "not resolved",
-			tone: result.projectName ? "default" : "dim"
-		}, {
-			key: "branch",
-			value: result.branch.name
-		}],
-		operationDescription: "Applying active branch change",
-		operationCount: 1,
-		details: ["Active branch updated in local CLI state for this repo."],
-		alerts: result.branch.kind === "production" ? [{
-			tone: "warning",
-			text: "Production is protected and durable. Use with care"
-		}] : void 0
-	}, context.ui);
-}
 //#endregion
-export { renderBranchList, renderBranchShow, renderBranchUse, serializeBranchList, serializeBranchShow };
+export { renderBranchList, serializeBranchList };

package/dist/shell/command-meta.js

@@ -69,8 +69,8 @@ const DESCRIPTORS = [
 	{
 		id: "branch",
 		path: ["prisma", "branch"],
-		description: "View your active Platform branches",
-		examples: ["prisma-cli branch list", "prisma-cli branch show"]
+		description: "View your Platform branches",
+		examples: ["prisma-cli branch list"]
 	},
 	{
 		id: "git",
@@ -153,29 +153,9 @@ const DESCRIPTORS = [
 			"branch",
 			"list"
 		],
-		description: "List active Platform branches for the resolved project",
+		description: "List Platform branches for the resolved project",
 		examples: ["prisma-cli branch list", "prisma-cli branch list --json"]
 	},
-	{
-		id: "branch.show",
-		path: [
-			"prisma",
-			"branch",
-			"show"
-		],
-		description: "Show the Platform branch matching your current Git branch",
-		examples: ["prisma-cli branch show", "prisma-cli branch show --json"]
-	},
-	{
-		id: "branch.use",
-		path: [
-			"prisma",
-			"branch",
-			"use"
-		],
-		description: "Change the local default branch context.",
-		examples: ["prisma-cli branch use", "prisma-cli branch use production"]
-	},
 	{
 		id: "app.build",
 		path: [
@@ -216,6 +196,7 @@ const DESCRIPTORS = [
 			"prisma-cli app deploy --app my-app --env DATABASE_URL=postgresql://example",
 			"prisma-cli app deploy --app my-app --framework nextjs --http-port 3000",
 			"prisma-cli app deploy --branch feat-login --framework hono",
+			"prisma-cli app deploy --prod --yes",
 			"pnpm dlx skills@latest add prisma/prisma-cli/skills#cli-v<cli-version> --all",
 			"prisma-cli app deploy --framework bun --entry src/server.ts"
 		]
@@ -378,7 +359,7 @@ const DESCRIPTORS = [
 		],
 		description: "Manage environment variables for the active project",
 		examples: [
-			"prisma-cli project env list --role production",
+			"prisma-cli project env list",
 			"prisma-cli project env add STRIPE_KEY=sk_test_xxx --role production",
 			"prisma-cli project env add DATABASE_URL=postgresql://branch --branch feature/foo",
 			"prisma-cli project env remove STRIPE_KEY --role preview"
@@ -425,6 +406,7 @@ const DESCRIPTORS = [
 		],
 		description: "List environment variable metadata for a scope (no values).",
 		examples: [
+			"prisma-cli project env list",
 			"prisma-cli project env list --role production",
 			"prisma-cli project env list --role preview",
 			"prisma-cli project env list --branch feature/foo"

package/dist/shell/command-runner.js

@@ -1,15 +1,20 @@
-import { CliError, authRequiredError } from "./errors.js";
+import { CliError, authRequiredError, commandCanceledError } from "./errors.js";
 import { cliErrorToJson, writeHumanError, writeHumanLines, writeJsonError, writeJsonEvent, writeJsonSuccess } from "./output.js";
 import { getCommandDescriptor } from "./command-meta.js";
 import { resolveGlobalFlags } from "./global-flags.js";
 import { createCommandContext } from "./runtime.js";
 import { AuthError } from "@prisma/management-api-sdk";
 //#region src/shell/command-runner.ts
-function toCliError(error) {
+function toCliError(error, runtime) {
+	if (isCancellationError(error) || runtime.signal.aborted) return commandCanceledError();
 	if (error instanceof CliError) return error;
 	if (error instanceof AuthError) return authRequiredError(["prisma-cli auth login"], { debug: error.message });
 	return null;
 }
+function isCancellationError(error) {
+	if (!(error instanceof Error)) return false;
+	return error.name === "AbortError" || error.name === "CancelledError";
+}
 async function runCommand(runtime, commandName, options, handler, presenter) {
 	const flags = resolveGlobalFlags(runtime.argv, options);
 	const context = await createCommandContext(runtime, flags);
@@ -26,7 +31,7 @@ async function runCommand(runtime, commandName, options, handler, presenter) {
 		if (flags.quiet) return;
 		writeHumanLines(context.output, presenter.renderHuman(context, descriptor, success.result));
 	} catch (error) {
-		const cliError = toCliError(error);
+		const cliError = toCliError(error, runtime);
 		if (cliError) {
 			if (flags.json) writeJsonError(context.output, commandName, cliError);
 			else writeHumanError(context.output, context.ui, cliError, { trace: flags.trace });
@@ -51,7 +56,7 @@ async function runStreamingCommand(runtime, commandName, options, handler) {
 			nextActions: []
 		});
 	} catch (error) {
-		const cliError = toCliError(error);
+		const cliError = toCliError(error, runtime);
 		if (cliError) {
 			if (flags.json) writeJsonEvent(context.output, {
 				type: "error",