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

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

@@ -24,20 +24,21 @@ function workspaceIdFromClaims(claims) {
 	const id = sub.slice(10).trim();
 	return id.length > 0 ? id : null;
 }
-async function performLogin(env) {
+async function performLogin(env, signal) {
 	await login({
-		tokenStorage: new FileTokenStorage(env),
-		env
+		tokenStorage: new FileTokenStorage(env, signal),
+		env,
+		signal
 	});
 }
-async function readAuthState(env) {
+async function readAuthState(env, signal) {
 	const rawServiceToken = env[SERVICE_TOKEN_ENV_VAR];
 	if (rawServiceToken !== void 0) {
 		const serviceToken = rawServiceToken.trim();
 		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);
+		return readServiceTokenAuthState(serviceToken, env, signal);
 	}
-	const tokens = await new FileTokenStorage(env).getTokens();
+	const tokens = await new FileTokenStorage(env, signal).getTokens();
 	if (!tokens) return {
 		authenticated: false,
 		provider: null,
@@ -45,20 +46,21 @@ async function readAuthState(env) {
 		workspace: null,
 		credential: null
 	};
-	const client = await requireComputeAuth(env);
-	const currentPrincipal = await readCurrentPrincipalAuthState(client);
+	const client = await requireComputeAuth(env, signal);
+	const currentPrincipal = await readCurrentPrincipalAuthState(client, signal);
 	if (currentPrincipal) return currentPrincipal;
 	const claims = decodeJwtPayload(tokens.accessToken);
 	return buildAuthState({
 		workspaceIdFromCredential: tokens.workspaceId,
 		claims,
 		env,
-		client
+		client,
+		signal
 	});
 }
-async function readServiceTokenAuthState(token, env) {
-	const client = await requireComputeAuth(env);
-	const currentPrincipal = await readCurrentPrincipalAuthState(client);
+async function readServiceTokenAuthState(token, env, signal) {
+	const client = await requireComputeAuth(env, signal);
+	const currentPrincipal = await readCurrentPrincipalAuthState(client, signal);
 	if (currentPrincipal) return currentPrincipal;
 	const claims = decodeJwtPayload(token);
 	const workspaceId = workspaceIdFromClaims(claims);
@@ -73,15 +75,19 @@ async function readServiceTokenAuthState(token, env) {
 		workspaceIdFromCredential: workspaceId,
 		claims,
 		env,
-		client
+		client,
+		signal
 	});
 }
-async function buildAuthState({ workspaceIdFromCredential, claims, env, client }) {
+async function buildAuthState({ workspaceIdFromCredential, claims, env, client, signal }) {
 	let workspaceId = workspaceIdFromCredential;
 	let workspaceName = workspaceIdFromCredential;
-	client ??= await requireComputeAuth(env);
+	client ??= await requireComputeAuth(env, signal);
 	if (client) try {
-		const { data, response } = await client.GET("/v1/workspaces/{id}", { params: { path: { id: workspaceIdFromCredential } } });
+		const { data, response } = await client.GET("/v1/workspaces/{id}", {
+			params: { path: { id: workspaceIdFromCredential } },
+			signal
+		});
 		if (response?.status === 401) return {
 			authenticated: false,
 			provider: null,
@@ -94,7 +100,9 @@ async function buildAuthState({ workspaceIdFromCredential, claims, env, client }
 			workspaceName = data.data.id;
 		}
 		if (data?.data?.name) workspaceName = data.data.name;
-	} catch {}
+	} catch {
+		signal?.throwIfAborted();
+	}
 	const email = emailFromClaims(claims);
 	return {
 		authenticated: true,
@@ -107,10 +115,10 @@ async function buildAuthState({ workspaceIdFromCredential, claims, env, client }
 		credential: null
 	};
 }
-async function readCurrentPrincipalAuthState(client) {
+async function readCurrentPrincipalAuthState(client, signal) {
 	if (!client) return null;
 	try {
-		const { data, response } = await client.GET("/v1/me");
+		const { data, response } = await client.GET("/v1/me", { signal });
 		if (response?.status === 401) return {
 			authenticated: false,
 			provider: null,
@@ -133,11 +141,12 @@ async function readCurrentPrincipalAuthState(client) {
 			credential: principal.credential
 		};
 	} catch {
+		signal?.throwIfAborted();
 		return null;
 	}
 }
-async function performLogout(env) {
-	await new FileTokenStorage(env).clearTokens();
+async function performLogout(env, signal) {
+	await new FileTokenStorage(env, signal).clearTokens();
 }
 //#endregion
 export { performLogin, performLogout, readAuthState };

package/dist/lib/auth/guard.js

@@ -11,7 +11,8 @@ import { createManagementApiClient, createManagementApiSdk } from "@prisma/manag
 *
 * Returns null if not authenticated.
 */
-async function requireComputeAuth(env = process.env) {
+async function requireComputeAuth(env = process.env, signal) {
+	signal?.throwIfAborted();
 	const rawToken = env[SERVICE_TOKEN_ENV_VAR];
 	if (rawToken !== void 0) {
 		const token = rawToken.trim();
@@ -21,7 +22,7 @@ async function requireComputeAuth(env = process.env) {
 			token
 		});
 	}
-	const tokenStorage = new FileTokenStorage(env);
+	const tokenStorage = new FileTokenStorage(env, signal);
 	if (!await tokenStorage.getTokens()) return null;
 	return createManagementApiSdk({
 		clientId: CLIENT_ID,

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/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/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",

package/dist/shell/errors.js

@@ -56,6 +56,17 @@ function authRequiredError(nextSteps = ["prisma-cli auth login"], options = {})
 		nextSteps
 	});
 }
+function commandCanceledError() {
+	return new CliError({
+		code: "COMMAND_CANCELED",
+		domain: "cli",
+		summary: "Command canceled",
+		why: null,
+		fix: null,
+		exitCode: 130,
+		humanLines: ["Command canceled [COMMAND_CANCELED]"]
+	});
+}
 function workspaceRequiredError() {
 	return usageError("Workspace required", "This command needs an active workspace, but the authenticated session does not have one.", "Run prisma-cli auth login and choose a workspace.", ["prisma-cli auth login"], "auth");
 }
@@ -71,4 +82,4 @@ function featureUnavailableError(summary, why, fix, nextSteps = [], domain = "cl
 	});
 }
 //#endregion
-export { CliError, authRequiredError, featureUnavailableError, usageError, workspaceRequiredError };
+export { CliError, authRequiredError, commandCanceledError, featureUnavailableError, usageError, workspaceRequiredError };

package/dist/shell/runtime.js

@@ -22,13 +22,13 @@ async function createCommandContext(runtime, flags) {
 	const fixturePath = runtime.fixturePath ?? runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
 	const stateDir = resolveStateDir(runtime);
 	let loadedApi;
-	if (fixturePath) loadedApi = await MockApi.load(fixturePath);
+	if (fixturePath) loadedApi = await MockApi.load(fixturePath, runtime.signal);
 	return {
 		get api() {
 			if (!loadedApi) throw new Error("context.api accessed in real mode. Set runtime.fixturePath or PRISMA_CLI_MOCK_FIXTURE_PATH to use fixture mode.");
 			return loadedApi;
 		},
-		stateStore: new LocalStateStore(stateDir),
+		stateStore: new LocalStateStore(stateDir, runtime.signal),
 		output: {
 			stdout: runtime.stdout,
 			stderr: runtime.stderr