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

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 path from "node:path";
+import "node:fs/promises";
 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) {
-	if (buildType === "bun" || buildType === "nextjs") return buildType;
-	if (buildType !== "auto") return null;
-	return detectLocalBuildType(appPath);
-}
-async function detectLocalBuildType(appPath) {
-	if (await isNextProject(appPath)) return "nextjs";
-	if (await isBunProject(appPath)) return "bun";
-	return null;
-}
 async function runLocalApp(options) {
 	const spawnImpl = options.spawnImpl ?? spawn;
 	if (options.buildType === "nextjs") {
@@ -58,7 +42,8 @@ async function runLocalApp(options) {
 			env: {
 				...options.env,
 				PORT: String(options.port)
-			}
+			},
+			signal: options.signal
 		}, spawnImpl, "Could not find the Next.js CLI. Install it with `npm install next` or ensure npx/bunx is available.");
 		return {
 			framework: "nextjs",
@@ -69,7 +54,7 @@ async function runLocalApp(options) {
 			signal: command.signal
 		};
 	}
-	const entrypoint = await resolveBunEntrypoint(options.appPath, options.entrypoint);
+	const entrypoint = await resolveBunEntrypoint(options.appPath, options.entrypoint, options.signal);
 	const command = await runWithFallback([{
 		command: "bun",
 		args: ["--watch", entrypoint],
@@ -79,7 +64,8 @@ async function runLocalApp(options) {
 		env: {
 			...options.env,
 			PORT: String(options.port)
-		}
+		},
+		signal: options.signal
 	}, spawnImpl, "Bun is required to run this app locally. Install it from https://bun.sh.");
 	return {
 		framework: "bun",
@@ -90,33 +76,6 @@ async function runLocalApp(options) {
 		signal: command.signal
 	};
 }
-async function isNextProject(appPath) {
-	for (const fileName of NEXT_CONFIG_FILENAMES) try {
-		await access(path.join(appPath, fileName));
-		return true;
-	} catch {}
-	return hasDependency(await readBunPackageJson(appPath), "next");
-}
-async function isBunProject(appPath) {
-	try {
-		await access(path.join(appPath, "bun.lock"));
-		return true;
-	} catch {}
-	try {
-		await access(path.join(appPath, "bun.lockb"));
-		return true;
-	} catch {}
-	const packageJson = await readBunPackageJson(appPath);
-	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);
@@ -147,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

@@ -0,0 +1,162 @@
+import { CliError } from "../../shell/errors.js";
+import { canPrompt } from "../../shell/runtime.js";
+import { confirmPrompt } from "../../shell/prompt.js";
+//#region src/lib/app/production-deploy-gate.ts
+async function enforceProductionDeployGate(context, provider, options) {
+	if (options.branchKind !== "production") return { firstProductionDeploy: false };
+	if (!options.appId) {
+		renderFirstProductionDeployLine(context, options.appName);
+		return { firstProductionDeploy: true };
+	}
+	const currentLiveDeployment = resolveCurrentProductionDeployment(await provider.listDeployments(options.appId).catch((error) => {
+		throw productionDeployInspectionFailedError(error);
+	}));
+	if (!currentLiveDeployment) {
+		renderFirstProductionDeployLine(context, options.appName);
+		return { firstProductionDeploy: true };
+	}
+	if (!options.prod) throw productionDeployRequiresFlagError();
+	if (context.flags.yes) {
+		renderProductionDeployYesLine(context);
+		return { firstProductionDeploy: false };
+	}
+	if (!canPrompt(context)) throw productionDeployConfirmationRequiredError(options.appName);
+	renderProductionDeployConfirmation(context, currentLiveDeployment);
+	if (!await confirmPrompt({
+		input: context.runtime.stdin,
+		output: context.output.stderr,
+		signal: context.runtime.signal,
+		message: "Deploy to production?",
+		initialValue: false
+	})) throw productionDeployCancelledError();
+	return { firstProductionDeploy: false };
+}
+function resolveCurrentProductionDeployment(result) {
+	if (result.deployments.length === 0) return null;
+	if (result.app.liveDeploymentId) {
+		const live = result.deployments.find((deployment) => deployment.id === result.app.liveDeploymentId);
+		if (live) return live;
+	}
+	return result.deployments.find((deployment) => deployment.live === true) ?? result.deployments[0] ?? null;
+}
+function renderFirstProductionDeployLine(context, appName) {
+	if (context.flags.json || context.flags.quiet) return;
+	context.output.stderr.write(`First deploy of "${appName}" -- promoting to production.\n\n`);
+}
+function renderProductionDeployYesLine(context) {
+	if (context.flags.json || context.flags.quiet) return;
+	context.output.stderr.write("Deploying to production (--prod --yes).\n\n");
+}
+function renderProductionDeployConfirmation(context, currentLiveDeployment) {
+	if (context.flags.json || context.flags.quiet) return;
+	const lines = [
+		"This will deploy to production and replace the live deployment.",
+		"",
+		`  Current live:  ${currentLiveDeployment.id} deployed ${formatDeploymentAge(currentLiveDeployment.createdAt)}`,
+		"  New deploy:    will be built from your local code",
+		""
+	];
+	context.output.stderr.write(`${lines.join("\n")}\n`);
+}
+function formatDeploymentAge(createdAt) {
+	const createdAtMs = Date.parse(createdAt);
+	if (!Number.isFinite(createdAtMs)) return createdAt;
+	const elapsedMs = Math.max(0, Date.now() - createdAtMs);
+	for (const unit of [
+		{
+			label: "day",
+			ms: 1440 * 60 * 1e3
+		},
+		{
+			label: "hour",
+			ms: 3600 * 1e3
+		},
+		{
+			label: "minute",
+			ms: 60 * 1e3
+		}
+	]) if (elapsedMs >= unit.ms) {
+		const value = Math.floor(elapsedMs / unit.ms);
+		return `${value} ${unit.label}${value === 1 ? "" : "s"} ago`;
+	}
+	return "less than a minute ago";
+}
+function productionDeployRequiresFlagError() {
+	return new CliError({
+		code: "PROD_DEPLOY_REQUIRES_FLAG",
+		domain: "app",
+		summary: "Production deploy requires --prod",
+		why: "The resolved Branch is production and this App already has a production deployment.",
+		fix: "Re-run with --prod, or deploy from a preview Branch.",
+		exitCode: 2,
+		nextActions: [{
+			kind: "run-command",
+			journey: "deploy-app",
+			label: "Deploy to production",
+			command: "prisma-cli app deploy --prod"
+		}, {
+			kind: "run-command",
+			journey: "deploy-app",
+			label: "Create a preview branch",
+			commands: ["git checkout -b <branch-name>", "prisma-cli app deploy"]
+		}],
+		humanLines: [
+			"This would deploy to production.",
+			"",
+			"Production deploys require explicit intent. Re-run with:",
+			"",
+			"  prisma-cli app deploy --prod",
+			"",
+			"Or deploy a preview from a feature branch:",
+			"",
+			"  git checkout -b <branch-name>",
+			"  prisma-cli app deploy"
+		]
+	});
+}
+function productionDeployConfirmationRequiredError(appName) {
+	return new CliError({
+		code: "CONFIRMATION_REQUIRED",
+		domain: "app",
+		summary: "Production deploy requires confirmation in the current mode",
+		why: "This command cannot prompt for production deploy confirmation in the current mode.",
+		fix: `Pass --prod --yes to confirm deployment of "${appName}" to production.`,
+		exitCode: 1,
+		nextSteps: ["prisma-cli app deploy --prod --yes"],
+		nextActions: [{
+			kind: "run-command",
+			journey: "deploy-app",
+			label: "Deploy to production non-interactively",
+			command: "prisma-cli app deploy --prod --yes"
+		}]
+	});
+}
+function productionDeployCancelledError() {
+	return new CliError({
+		code: "CONFIRMATION_REQUIRED",
+		domain: "app",
+		summary: "Production deploy cancelled",
+		why: null,
+		fix: null,
+		exitCode: 0,
+		humanLines: ["Cancelled."]
+	});
+}
+function productionDeployInspectionFailedError(error) {
+	return new CliError({
+		code: "DEPLOY_FAILED",
+		domain: "app",
+		summary: "Failed to inspect production deployments",
+		why: error instanceof Error ? error.message : String(error),
+		fix: "Retry the command, or rerun with --trace for more detailed diagnostics.",
+		debug: formatDebugDetails(error),
+		exitCode: 1,
+		nextSteps: ["prisma-cli app list-deploys"]
+	});
+}
+function formatDebugDetails(error) {
+	if (error instanceof Error) return error.stack ?? error.message;
+	return typeof error === "string" ? error : null;
+}
+//#endregion
+export { enforceProductionDeployGate };

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

@@ -24,20 +24,22 @@ 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, { activateOnSetTokens: true }),
+		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 tokenStorage = new FileTokenStorage(env, signal);
+	const tokens = await tokenStorage.getTokens();
 	if (!tokens) return {
 		authenticated: false,
 		provider: null,
@@ -45,20 +47,26 @@ async function readAuthState(env) {
 		workspace: null,
 		credential: null
 	};
-	const client = await requireComputeAuth(env);
-	const currentPrincipal = await readCurrentPrincipalAuthState(client);
-	if (currentPrincipal) return currentPrincipal;
+	const client = await requireComputeAuth(env, signal);
+	const currentPrincipal = await readCurrentPrincipalAuthState(client, signal);
+	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
+		client,
+		signal
 	});
+	if (authState.authenticated && authState.workspace) await tokenStorage.rememberWorkspace?.(tokens.workspaceId, authState.workspace);
+	return authState;
 }
-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 +81,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 +106,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 +121,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 +147,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,10 @@ async function requireComputeAuth(env = process.env) {
 			token
 		});
 	}
-	const tokenStorage = new FileTokenStorage(env);
+	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

@@ -1,9 +1,10 @@
 import { getApiBaseUrl } from "./client.js";
 import { FileTokenStorage } from "../../adapters/token-storage.js";
-import open from "open";
 import { AuthError, createManagementApiSdk } from "@prisma/management-api-sdk";
+import open from "open";
 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,94 @@ 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 (;;) {
+			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;
 	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, { activateOnSetTokens: true });
 		this.sdk = createManagementApiSdk({
 			clientId: options.clientId ?? "cmm3lndn701oo0uefvxzo0ivw",
 			redirectUri: `http://${options.hostname}:${options.port}/auth/callback`,
@@ -76,8 +160,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 +174,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 +213,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;
 		}
 	}