@prisma/cli 2.20.1 → 3.0.0-alpha.1

package/dist/lib/app/preview-build.js

@@ -0,0 +1,142 @@
+import { resolveBunEntrypoint } from "./bun-project.js";
+import path from "node:path";
+import { cp, readdir, readlink, rm, stat } from "node:fs/promises";
+import { AstroBuild, BunBuild, NextjsBuild, NuxtBuild, TanstackStartBuild } from "@prisma/compute-sdk";
+//#region src/lib/app/preview-build.ts
+const PREVIEW_BUILD_TYPES = [
+	"auto",
+	"bun",
+	"nextjs",
+	"nuxt",
+	"astro",
+	"tanstack-start"
+];
+const RESOLVED_PREVIEW_BUILD_TYPES = PREVIEW_BUILD_TYPES.filter((buildType) => buildType !== "auto");
+var PreviewBuildStrategy = class {
+	#appPath;
+	#entrypoint;
+	#buildType;
+	constructor(options) {
+		this.#appPath = options.appPath;
+		this.#entrypoint = options.entrypoint;
+		this.#buildType = options.buildType ?? "auto";
+	}
+	async canBuild() {
+		const { strategy } = await resolvePreviewBuildStrategy({
+			appPath: this.#appPath,
+			entrypoint: this.#entrypoint,
+			buildType: this.#buildType
+		});
+		return strategy.canBuild();
+	}
+	async execute() {
+		const { artifact } = await executePreviewBuild({
+			appPath: this.#appPath,
+			entrypoint: this.#entrypoint,
+			buildType: this.#buildType
+		});
+		return artifact;
+	}
+};
+async function executePreviewBuild(options) {
+	const { strategy, buildType } = await resolvePreviewBuildStrategy({
+		appPath: options.appPath,
+		entrypoint: options.entrypoint,
+		buildType: options.buildType ?? "auto"
+	});
+	const artifact = await strategy.execute();
+	try {
+		await normalizeArtifactSymlinks(artifact.directory, options.appPath);
+		return {
+			artifact,
+			buildType
+		};
+	} catch (error) {
+		await artifact.cleanup?.().catch(() => void 0);
+		throw error;
+	}
+}
+async function resolvePreviewBuildStrategy(options) {
+	if (options.buildType !== "auto") {
+		const strategy = await createPreviewBuildStrategy({
+			appPath: options.appPath,
+			entrypoint: options.entrypoint,
+			buildType: options.buildType
+		});
+		return {
+			buildType: options.buildType,
+			strategy
+		};
+	}
+	for (const buildType of RESOLVED_PREVIEW_BUILD_TYPES) {
+		if (buildType === "bun") continue;
+		const strategy = await createPreviewBuildStrategy({
+			appPath: options.appPath,
+			entrypoint: options.entrypoint,
+			buildType
+		});
+		if (await strategy.canBuild()) return {
+			buildType,
+			strategy
+		};
+	}
+	return {
+		buildType: "bun",
+		strategy: await createPreviewBuildStrategy({
+			appPath: options.appPath,
+			entrypoint: options.entrypoint,
+			buildType: "bun"
+		})
+	};
+}
+async function createPreviewBuildStrategy(options) {
+	switch (options.buildType) {
+		case "nextjs": return new NextjsBuild({ appPath: options.appPath });
+		case "nuxt": return new NuxtBuild({ appPath: options.appPath });
+		case "astro": return new AstroBuild({ appPath: options.appPath });
+		case "tanstack-start": return new TanstackStartBuild({ appPath: options.appPath });
+		case "bun": {
+			const entrypoint = await resolveBunEntrypoint(options.appPath, options.entrypoint);
+			return new BunBuild({
+				appPath: options.appPath,
+				entrypoint
+			});
+		}
+	}
+}
+async function normalizeArtifactSymlinks(artifactDir, appPath) {
+	const normalizedArtifactDir = path.resolve(artifactDir);
+	const normalizedAppPath = path.resolve(appPath);
+	await walkDirectory(normalizedArtifactDir);
+	async function walkDirectory(directory) {
+		const entries = await readdir(directory, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path.join(directory, entry.name);
+			if (entry.isDirectory()) {
+				await walkDirectory(fullPath);
+				continue;
+			}
+			if (!entry.isSymbolicLink()) continue;
+			const target = await readlink(fullPath);
+			const resolvedTarget = path.resolve(path.dirname(fullPath), target);
+			if (isPathWithin(normalizedArtifactDir, resolvedTarget)) continue;
+			if (!isPathWithin(normalizedAppPath, resolvedTarget)) throw new Error(`Build artifact symlink escapes the app directory: ${resolvedTarget}`);
+			const targetStat = await stat(resolvedTarget);
+			await rm(fullPath, {
+				force: true,
+				recursive: true
+			});
+			await cp(resolvedTarget, fullPath, {
+				recursive: targetStat.isDirectory(),
+				dereference: true
+			});
+			if (targetStat.isDirectory()) await walkDirectory(fullPath);
+		}
+	}
+}
+function isPathWithin(rootPath, candidatePath) {
+	const relativePath = path.relative(rootPath, candidatePath);
+	return relativePath === "" || !relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath);
+}
+//#endregion
+export { PREVIEW_BUILD_TYPES, PreviewBuildStrategy, RESOLVED_PREVIEW_BUILD_TYPES, executePreviewBuild };

package/dist/lib/app/preview-interaction.js

@@ -0,0 +1,38 @@
+import { selectPrompt, textPrompt } from "../../shell/prompt.js";
+//#region src/lib/app/preview-interaction.ts
+const CREATE_NEW_APP = "__create_new_app__";
+const PREVIEW_DEFAULT_REGION = "eu-central-1";
+function createPreviewDeployInteraction(context) {
+	return {
+		async selectService(services) {
+			const sorted = services.slice().sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
+			const selection = await selectPrompt({
+				input: context.runtime.stdin,
+				output: context.runtime.stderr,
+				message: "Select an app",
+				choices: [...sorted.map((service) => ({
+					label: service.name,
+					value: service.id
+				})), {
+					label: "Create a new app",
+					value: CREATE_NEW_APP
+				}]
+			});
+			return selection === CREATE_NEW_APP ? null : selection;
+		},
+		async provideServiceName() {
+			return textPrompt({
+				input: context.runtime.stdin,
+				output: context.runtime.stderr,
+				message: "App name",
+				placeholder: "hello-world",
+				validate: (value) => !value?.trim() ? "App name is required" : void 0
+			}).then((value) => value.trim());
+		},
+		async selectRegion(_regions) {
+			return PREVIEW_DEFAULT_REGION;
+		}
+	};
+}
+//#endregion
+export { PREVIEW_DEFAULT_REGION, createPreviewDeployInteraction };

package/dist/lib/app/preview-progress.js

@@ -0,0 +1,139 @@
+//#region src/lib/app/preview-progress.ts
+function createPreviewDeployProgress(output, enabled) {
+	if (!enabled) return;
+	const write = (line) => {
+		output.write(`${line}\n`);
+	};
+	return {
+		onBuildStart() {
+			write("Building application...");
+		},
+		onBuildComplete() {
+			write("Build complete.");
+		},
+		onArchiveCreating() {
+			write("Creating deployment artifact...");
+		},
+		onArchiveReady(byteLength) {
+			write(`Artifact ready (${(byteLength / 1024).toFixed(1)} KB).`);
+		},
+		onVersionCreated(versionId) {
+			write(`Deployment ${versionId} created.`);
+		},
+		onUploadComplete() {
+			write("Upload complete.");
+		},
+		onStartRequested() {
+			write("Starting deployment...");
+		},
+		onStatusChange(status) {
+			write(`Status: ${status}`);
+		},
+		onRunning(url) {
+			if (url) {
+				write(`Deployment is running at ${url}.`);
+				return;
+			}
+			write("Deployment is running.");
+		},
+		onPromoteStart() {
+			write("Promoting deployment...");
+		},
+		onPromoted(url) {
+			if (url) {
+				write(`Promoted to ${url}.`);
+				return;
+			}
+			write("Promotion complete.");
+		},
+		onPromoteFailed(error) {
+			write(`Promotion failed${error?.message ? `: ${error.message}` : "."}`);
+		},
+		onOldVersionStopping(versionId) {
+			write(`Stopping previous deployment ${versionId}...`);
+		},
+		onOldVersionStopped(versionId) {
+			write(`Previous deployment ${versionId} stopped.`);
+		},
+		onOldVersionStopFailed(versionId) {
+			write(`Failed to stop previous deployment ${versionId} (non-fatal).`);
+		},
+		onOldVersionDeleting(versionId) {
+			write(`Deleting previous deployment ${versionId}...`);
+		},
+		onOldVersionDeleted(versionId) {
+			write(`Previous deployment ${versionId} deleted.`);
+		},
+		onOldVersionDeleteFailed(versionId) {
+			write(`Failed to delete previous deployment ${versionId} (non-fatal).`);
+		},
+		onCleanupDanglingVersion(versionId) {
+			write(`Cleaning up deployment ${versionId}...`);
+		},
+		onCleanupDanglingVersionComplete(versionId) {
+			write(`Deployment ${versionId} cleaned up.`);
+		},
+		onCleanupDanglingVersionFailed(versionId) {
+			write(`Failed to clean up deployment ${versionId}.`);
+		}
+	};
+}
+function createPreviewPromoteProgress(output, enabled) {
+	if (!enabled) return;
+	const write = (line) => {
+		output.write(`${line}\n`);
+	};
+	return {
+		onVersionStarting(versionId) {
+			write(`Starting deployment ${versionId}...`);
+		},
+		onVersionStartRequested() {
+			write("Requesting deployment start...");
+		},
+		onStatusChange(status) {
+			write(`Status: ${status}`);
+		},
+		onVersionRunning() {
+			write("Deployment is running.");
+		},
+		onPromoteStart() {
+			write("Promoting deployment...");
+		},
+		onPromoted(url) {
+			if (url) {
+				write(`Promoted to ${url}.`);
+				return;
+			}
+			write("Promotion complete.");
+		},
+		onPromoteFailed(error) {
+			write(`Promotion failed${error?.message ? `: ${error.message}` : "."}`);
+		}
+	};
+}
+function createPreviewUpdateEnvProgress(output, enabled) {
+	if (!enabled) return;
+	const write = (line) => {
+		output.write(`${line}\n`);
+	};
+	return {
+		onVersionCreated(versionId) {
+			write(`Creating updated deployment ${versionId}...`);
+		},
+		onStartRequested() {
+			write("Starting deployment...");
+		},
+		onStatusChange(status) {
+			write(`Status: ${status}`);
+		},
+		onRunning(url) {
+			if (url) {
+				write(`Deployment is running at ${url}.`);
+				return;
+			}
+			write("Deployment is running.");
+		}
+	};
+}
+//#endregion
+export { createPreviewDeployProgress, createPreviewPromoteProgress, createPreviewUpdateEnvProgress };

package/dist/lib/app/preview-provider.js

@@ -0,0 +1,232 @@
+import { envVarNames } from "./env-vars.js";
+import { PreviewBuildStrategy } from "./preview-build.js";
+import path from "node:path";
+import { ApiError, ComputeClient } from "@prisma/compute-sdk";
+//#region src/lib/app/preview-provider.ts
+function createPreviewAppProvider(client) {
+	const sdk = new ComputeClient(client);
+	return {
+		async createProject(options) {
+			const projectResult = await sdk.createProject({ name: options.name });
+			if (projectResult.isErr()) throw new Error(projectResult.error.message);
+			return {
+				id: projectResult.value.id,
+				name: projectResult.value.name
+			};
+		},
+		async listApps(projectId) {
+			const servicesResult = await sdk.listServices({ projectId });
+			if (servicesResult.isErr()) throw new Error(servicesResult.error.message);
+			return (await Promise.all(servicesResult.value.map(async (service) => {
+				const detailResult = await sdk.showService({ serviceId: service.id });
+				return detailResult.isOk() ? detailResult.value : {
+					id: service.id,
+					name: service.name,
+					region: service.region,
+					latestVersionId: null,
+					serviceEndpointDomain: void 0
+				};
+			}))).map((service) => ({
+				id: service.id,
+				name: service.name,
+				region: service.region ?? null,
+				liveDeploymentId: service.latestVersionId ?? null,
+				liveUrl: toAbsoluteUrl(service.serviceEndpointDomain ?? null)
+			}));
+		},
+		async removeApp(appId) {
+			const appResult = await sdk.showService({ serviceId: appId });
+			if (appResult.isErr()) throw new Error(appResult.error.message);
+			const destroyResult = await sdk.destroyService({
+				serviceId: appId,
+				keepService: false,
+				timeoutSeconds: 120,
+				pollIntervalMs: 2e3
+			});
+			if (destroyResult.isErr()) throw new Error(destroyResult.error.message);
+			return {
+				id: appResult.value.id,
+				name: appResult.value.name
+			};
+		},
+		async promoteDeployment(options) {
+			const promoteResult = await sdk.promote({
+				serviceId: options.appId,
+				versionId: options.deploymentId,
+				timeoutSeconds: 120,
+				pollIntervalMs: 2e3,
+				progress: options.progress
+			});
+			if (promoteResult.isErr()) throw new Error(promoteResult.error.message);
+		},
+		async deployApp(options) {
+			const deployResult = await sdk.deploy({
+				strategy: new PreviewBuildStrategy({
+					appPath: path.resolve(options.cwd),
+					entrypoint: options.entrypoint,
+					buildType: options.buildType
+				}),
+				projectId: options.projectId,
+				serviceId: options.appId,
+				serviceName: options.appName,
+				region: options.region,
+				portMapping: options.portMapping,
+				envVars: options.envVars,
+				timeoutSeconds: 120,
+				pollIntervalMs: 2e3,
+				interaction: options.interaction,
+				progress: options.progress
+			});
+			if (deployResult.isErr()) throw new Error(deployResult.error.message);
+			const deployed = deployResult.value;
+			return {
+				projectId: deployed.projectId,
+				app: {
+					id: deployed.serviceId,
+					name: deployed.serviceName,
+					region: deployed.region ?? null,
+					liveDeploymentId: deployed.versionId,
+					liveUrl: toAbsoluteUrl(deployed.serviceEndpointDomain ?? null)
+				},
+				deployment: {
+					id: deployed.versionId,
+					status: "running",
+					url: toAbsoluteUrl(deployed.serviceEndpointDomain ?? deployed.versionEndpointDomain ?? null)
+				}
+			};
+		},
+		async updateAppEnv(options) {
+			const updateResult = await sdk.updateEnv({
+				serviceId: options.appId,
+				envVars: options.envVars,
+				timeoutSeconds: 120,
+				pollIntervalMs: 2e3,
+				progress: options.progress
+			});
+			if (updateResult.isErr()) throw new Error(updateResult.error.message);
+			const promoteResult = await sdk.promote({
+				serviceId: options.appId,
+				versionId: updateResult.value.versionId,
+				timeoutSeconds: 120,
+				pollIntervalMs: 2e3,
+				progress: options.promoteProgress
+			});
+			if (promoteResult.isErr()) throw new Error(promoteResult.error.message);
+			const [serviceResult, versionResult] = await Promise.all([sdk.showService({ serviceId: options.appId }), sdk.showVersion({ versionId: updateResult.value.versionId })]);
+			if (serviceResult.isErr()) throw new Error(serviceResult.error.message);
+			if (versionResult.isErr()) throw new Error(versionResult.error.message);
+			return {
+				projectId: updateResult.value.projectId,
+				app: {
+					id: serviceResult.value.id,
+					name: serviceResult.value.name,
+					region: serviceResult.value.region ?? null,
+					liveDeploymentId: serviceResult.value.latestVersionId ?? null,
+					liveUrl: toAbsoluteUrl(serviceResult.value.serviceEndpointDomain ?? null)
+				},
+				deployment: {
+					id: versionResult.value.id,
+					status: versionResult.value.status,
+					createdAt: versionResult.value.createdAt,
+					url: toAbsoluteUrl(serviceResult.value.serviceEndpointDomain ?? versionResult.value.previewDomain ?? null),
+					live: true
+				},
+				variables: envVarNames(versionResult.value.envVars)
+			};
+		},
+		async listAppEnvNames(options) {
+			const [serviceResult, versionResult] = await Promise.all([sdk.showService({ serviceId: options.appId }), sdk.showVersion({ versionId: options.deploymentId })]);
+			if (serviceResult.isErr()) throw new Error(serviceResult.error.message);
+			if (versionResult.isErr()) throw new Error(versionResult.error.message);
+			return {
+				projectId: serviceResult.value.projectId,
+				app: {
+					id: serviceResult.value.id,
+					name: serviceResult.value.name,
+					region: serviceResult.value.region ?? null,
+					liveDeploymentId: serviceResult.value.latestVersionId ?? null,
+					liveUrl: toAbsoluteUrl(serviceResult.value.serviceEndpointDomain ?? null)
+				},
+				deployment: {
+					id: versionResult.value.id,
+					status: versionResult.value.status,
+					createdAt: versionResult.value.createdAt,
+					url: toAbsoluteUrl(versionResult.value.previewDomain ?? null),
+					live: serviceResult.value.latestVersionId === versionResult.value.id
+				},
+				variables: envVarNames(versionResult.value.envVars)
+			};
+		},
+		async listDeployments(appId) {
+			const [appResult, versionsResult] = await Promise.all([sdk.showService({ serviceId: appId }), sdk.listVersions({ serviceId: appId })]);
+			if (appResult.isErr()) throw new Error(appResult.error.message);
+			if (versionsResult.isErr()) throw new Error(versionsResult.error.message);
+			return {
+				app: {
+					id: appResult.value.id,
+					name: appResult.value.name,
+					region: appResult.value.region ?? null,
+					liveDeploymentId: appResult.value.latestVersionId ?? null,
+					liveUrl: toAbsoluteUrl(appResult.value.serviceEndpointDomain ?? null)
+				},
+				deployments: versionsResult.value.slice().sort((left, right) => {
+					const byDate = right.createdAt.localeCompare(left.createdAt);
+					return byDate !== 0 ? byDate : right.id.localeCompare(left.id);
+				}).map((deployment) => ({
+					id: deployment.id,
+					status: deployment.status,
+					createdAt: deployment.createdAt,
+					url: toAbsoluteUrl(deployment.previewDomain ?? null),
+					live: null
+				}))
+			};
+		},
+		async showDeployment(deploymentId) {
+			const deploymentResult = await sdk.showVersion({ versionId: deploymentId });
+			if (deploymentResult.isErr()) {
+				if (ApiError.is(deploymentResult.error) && deploymentResult.error.statusCode === 404) return null;
+				throw new Error(deploymentResult.error.message);
+			}
+			return {
+				app: await findAppForDeployment(sdk, deploymentId),
+				deployment: {
+					id: deploymentResult.value.id,
+					status: deploymentResult.value.status,
+					createdAt: deploymentResult.value.createdAt,
+					url: toAbsoluteUrl(deploymentResult.value.previewDomain ?? null),
+					live: null
+				}
+			};
+		}
+	};
+}
+async function findAppForDeployment(sdk, deploymentId) {
+	const projectsResult = await sdk.listProjects();
+	if (projectsResult.isErr()) throw new Error(projectsResult.error.message);
+	for (const project of projectsResult.value) {
+		const servicesResult = await sdk.listServices({ projectId: project.id });
+		if (servicesResult.isErr()) throw new Error(servicesResult.error.message);
+		for (const service of servicesResult.value) {
+			const detailResult = await sdk.showService({ serviceId: service.id });
+			if (detailResult.isErr()) throw new Error(detailResult.error.message);
+			const app = {
+				id: detailResult.value.id,
+				name: detailResult.value.name,
+				region: detailResult.value.region ?? null,
+				liveDeploymentId: detailResult.value.latestVersionId ?? null,
+				liveUrl: toAbsoluteUrl(detailResult.value.serviceEndpointDomain ?? null)
+			};
+			if (app.liveDeploymentId === deploymentId) return app;
+			const versionsResult = await sdk.listVersions({ serviceId: service.id });
+			if (versionsResult.isErr()) throw new Error(versionsResult.error.message);
+			if (versionsResult.value.some((version) => version.id === deploymentId)) return app;
+		}
+	}
+	return null;
+}
+function toAbsoluteUrl(url) {
+	if (!url) return null;
+	return url.startsWith("https://") || url.startsWith("http://") ? url : `https://${url}`;
+}
+//#endregion
+export { createPreviewAppProvider };

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

@@ -0,0 +1,57 @@
+import { FileTokenStorage } from "../../adapters/token-storage.js";
+import { requireComputeAuth } from "./guard.js";
+import { login } from "./login.js";
+//#region src/lib/auth/auth-ops.ts
+function decodeJwtPayload(token) {
+	try {
+		const payload = token.split(".")[1];
+		if (!payload) return {};
+		return JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+	} catch {
+		return {};
+	}
+}
+async function performLogin(env) {
+	await login({
+		tokenStorage: new FileTokenStorage(env),
+		env
+	});
+}
+async function readAuthState(env) {
+	const tokens = await new FileTokenStorage(env).getTokens();
+	if (!tokens) return {
+		authenticated: false,
+		provider: null,
+		user: null,
+		workspace: null,
+		linkedProjectId: null
+	};
+	const claims = decodeJwtPayload(tokens.accessToken);
+	const client = await requireComputeAuth(env);
+	let workspaceId = tokens.workspaceId;
+	let workspaceName = tokens.workspaceId;
+	if (client) try {
+		const { data } = await client.GET("/v1/workspaces/{id}", { params: { path: { id: tokens.workspaceId } } });
+		if (data?.data?.id) workspaceId = data.data.id;
+		if (data?.data?.name) workspaceName = data.data.name;
+	} catch {}
+	return {
+		authenticated: true,
+		provider: null,
+		user: {
+			id: claims.sub ?? "",
+			name: claims.name ?? "",
+			email: claims.email ?? ""
+		},
+		workspace: {
+			id: workspaceId,
+			name: workspaceName
+		},
+		linkedProjectId: null
+	};
+}
+async function performLogout(env) {
+	await new FileTokenStorage(env).clearTokens();
+}
+//#endregion
+export { performLogin, performLogout, readAuthState };

package/dist/lib/auth/client.js

@@ -0,0 +1,22 @@
+import path from "node:path";
+import os from "node:os";
+//#region src/lib/auth/client.ts
+const CLIENT_ID = "cmm3lndn701oo0uefvxzo0ivw";
+const SERVICE_TOKEN_ENV_VAR = "PRISMA_API_TOKEN";
+const AUTH_FILE_ENV_VAR = "PRISMA_COMPUTE_AUTH_FILE";
+function getApiBaseUrl(env = process.env) {
+	return env.PRISMA_MANAGEMENT_API_URL?.trim() || "https://api.prisma.io";
+}
+function getAuthFilePath(env = process.env) {
+	const configured = env[AUTH_FILE_ENV_VAR];
+	if (configured?.trim()) return path.resolve(configured);
+	if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Application Support", "prisma", "auth.json");
+	if (process.platform === "win32") {
+		const appData = env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+		return path.join(appData, "prisma", "auth.json");
+	}
+	const xdgConfigHome = env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+	return path.join(xdgConfigHome, "prisma", "auth.json");
+}
+//#endregion
+export { CLIENT_ID, SERVICE_TOKEN_ENV_VAR, getApiBaseUrl, getAuthFilePath };

package/dist/lib/auth/guard.js

@@ -0,0 +1,34 @@
+import { CLIENT_ID, SERVICE_TOKEN_ENV_VAR, getApiBaseUrl } from "./client.js";
+import { FileTokenStorage } from "../../adapters/token-storage.js";
+import { createManagementApiClient, createManagementApiSdk } from "@prisma/management-api-sdk";
+//#region src/lib/auth/guard.ts
+/**
+* Resolve authentication and return a ManagementApiClient.
+*
+* Priority:
+*   1. PRISMA_API_TOKEN env var → service token (CI / headless)
+*   2. Stored OAuth tokens     → SDK with auto-refresh
+*
+* Returns null if not authenticated.
+*/
+async function requireComputeAuth(env = process.env) {
+	const rawToken = env[SERVICE_TOKEN_ENV_VAR];
+	if (rawToken !== void 0) {
+		const token = rawToken.trim();
+		if (token.length === 0) throw new Error(`${SERVICE_TOKEN_ENV_VAR} is set but empty. Provide a valid token or unset the variable.`);
+		return createManagementApiClient({
+			baseUrl: getApiBaseUrl(env),
+			token
+		});
+	}
+	const tokenStorage = new FileTokenStorage(env);
+	if (!await tokenStorage.getTokens()) return null;
+	return createManagementApiSdk({
+		clientId: CLIENT_ID,
+		redirectUri: "http://localhost:0/auth/callback",
+		tokenStorage,
+		apiBaseUrl: getApiBaseUrl(env)
+	}).client;
+}
+//#endregion
+export { requireComputeAuth };