@prisma/cli 8.0.0-rc.1 → 8.0.0-rc.2

package/dist/auth/recipient.js

@@ -1,42 +0,0 @@
-import { getApiBaseUrl } from "./client.js";
-import { FileTokenStorage } from "./token-storage.js";
-import { createManagementApiSdk } from "@prisma/management-api-sdk";
-//#region src/auth/recipient.ts
-var RecipientSessionInvalidError = class extends Error {
-	constructor(workspaceRef) {
-		super(`The stored session for workspace "${workspaceRef}" could not be validated.`);
-		this.workspaceRef = workspaceRef;
-		this.name = "RecipientSessionInvalidError";
-	}
-};
-/**
-* Resolve a locally stored OAuth workspace session and return a validated
-* access token for it, refreshing through the SDK when the stored token has
-* expired. The active workspace pointer is never touched.
-*
-* Throws WorkspaceSelectionError when the ref does not match exactly one
-* stored session, and RecipientSessionInvalidError when the session cannot
-* be validated or refreshed.
-*/
-async function resolveRecipientWorkspaceSession(workspaceRef, env = process.env, signal) {
-	const workspace = await new FileTokenStorage(env, signal).resolveWorkspace(workspaceRef);
-	const pinnedStorage = new FileTokenStorage(env, signal, {
-		activateOnSetTokens: false,
-		lockSetTokens: false,
-		pinnedWorkspaceId: workspace.credentialWorkspaceId
-	});
-	if ((await createManagementApiSdk({
-		clientId: "cmm3lndn701oo0uefvxzo0ivw",
-		redirectUri: "http://localhost:0/auth/callback",
-		tokenStorage: pinnedStorage,
-		apiBaseUrl: getApiBaseUrl(env)
-	}).client.GET("/v1/workspaces", { signal })).error) throw new RecipientSessionInvalidError(workspaceRef);
-	const tokens = await pinnedStorage.getTokens();
-	if (!tokens) throw new RecipientSessionInvalidError(workspaceRef);
-	return {
-		workspace,
-		accessToken: tokens.accessToken
-	};
-}
-//#endregion
-export { RecipientSessionInvalidError, resolveRecipientWorkspaceSession };

package/dist/auth/token-storage.js

@@ -1,439 +0,0 @@
-import { getAuthFilePath } from "./client.js";
-import { sameWorkspaceId } from "../lib/workspace-id.js";
-import path from "node:path";
-import fs from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { CredentialsStore } from "@prisma/credentials-store";
-//#region src/auth/token-storage.ts
-const REFRESH_LOCK_RETRY_MS = 100;
-const REFRESH_LOCK_STALE_MS = 3e4;
-const REFRESH_LOCK_WAIT_TIMEOUT_MS = 25e3;
-const EMPTY_AUTH_CONTEXT = {
-	activeWorkspaceId: null,
-	workspaces: {}
-};
-const UNKNOWN_WORKSPACE_NAME = "Unknown workspace";
-function getAuthContextFilePath(authFilePath) {
-	const extension = path.extname(authFilePath);
-	if (!extension) return `${authFilePath}.context.json`;
-	return `${authFilePath.slice(0, -extension.length)}.context${extension}`;
-}
-function findLatestValidTokens(allCredentials) {
-	for (let i = allCredentials.length - 1; i >= 0; i -= 1) {
-		const credential = allCredentials[i];
-		if (!credential) continue;
-		if (typeof credential.workspaceId !== "string" || credential.workspaceId.length === 0 || typeof credential.token !== "string" || credential.token.length === 0 || typeof credential.refreshToken !== "string" || credential.refreshToken.length === 0) continue;
-		return {
-			workspaceId: credential.workspaceId,
-			accessToken: credential.token,
-			refreshToken: credential.refreshToken
-		};
-	}
-	return null;
-}
-function storedCredentialToTokens(credential) {
-	if (!credential) return null;
-	if (typeof credential.workspaceId !== "string" || credential.workspaceId.length === 0 || typeof credential.token !== "string" || credential.token.length === 0 || typeof credential.refreshToken !== "string" || credential.refreshToken.length === 0) return null;
-	return {
-		workspaceId: credential.workspaceId,
-		accessToken: credential.token,
-		refreshToken: credential.refreshToken
-	};
-}
-function findTokensForWorkspace(allCredentials, workspaceId) {
-	return storedCredentialToTokens(allCredentials.find((credential) => credential?.workspaceId === workspaceId)) ?? null;
-}
-function tokensEqual(a, b) {
-	return a?.workspaceId === b?.workspaceId && a?.accessToken === b?.accessToken && a?.refreshToken === b?.refreshToken;
-}
-function sleep(ms, signal) {
-	signal?.throwIfAborted();
-	return new Promise((resolve, reject) => {
-		const onAbort = () => {
-			clearTimeout(timeout);
-			reject(signal?.reason);
-		};
-		const timeout = setTimeout(() => {
-			signal?.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		signal?.addEventListener("abort", onAbort, { once: true });
-	});
-}
-var FileTokenStorage = class {
-	credentialsStore;
-	authFilePath;
-	contextFilePath;
-	lockFilePath;
-	constructor(env = process.env, signal, options = {}) {
-		this.signal = signal;
-		this.options = options;
-		const authFilePath = getAuthFilePath(env);
-		this.authFilePath = authFilePath;
-		this.contextFilePath = getAuthContextFilePath(authFilePath);
-		this.credentialsStore = new CredentialsStore(authFilePath);
-		this.lockFilePath = `${authFilePath}.lock`;
-	}
-	async getTokens() {
-		this.signal?.throwIfAborted();
-		try {
-			const credentials = await this.readCredentialsFromDisk();
-			if (this.options.pinnedWorkspaceId) return findTokensForWorkspace(credentials, this.options.pinnedWorkspaceId);
-			const context = await this.readAuthContext();
-			if (context.state.activeWorkspaceId) return findTokensForWorkspace(credentials, context.state.activeWorkspaceId);
-			const latest = findLatestValidTokens(credentials);
-			if (!latest) return null;
-			if (!context.exists) {
-				await this.setActiveWorkspaceId(latest.workspaceId);
-				return latest;
-			}
-			return null;
-		} catch (_error) {
-			if (this.signal?.aborted) throw this.signal.reason;
-			return null;
-		}
-	}
-	async setTokens(tokens) {
-		if (this.options.lockSetTokens === false) {
-			await this.setTokensUnlocked(tokens);
-			return;
-		}
-		await this.withRefreshLock(() => this.setTokensUnlocked(tokens));
-	}
-	async setTokensUnlocked(tokens) {
-		this.signal?.throwIfAborted();
-		await this.credentialsStore.storeCredentials({
-			workspaceId: tokens.workspaceId,
-			token: tokens.accessToken,
-			refreshToken: tokens.refreshToken
-		});
-		this.signal?.throwIfAborted();
-		await this.rememberWorkspaceUnlocked(tokens.workspaceId, {
-			id: tokens.workspaceId,
-			name: tokens.workspaceId
-		});
-		await this.maybeActivateWorkspaceId(tokens.workspaceId);
-	}
-	async clearTokens() {
-		await this.withRefreshLock(() => this.clearTokensUnlocked());
-	}
-	async clearTokensUnlocked() {
-		this.signal?.throwIfAborted();
-		await fs.mkdir(path.dirname(this.authFilePath), { recursive: true });
-		this.signal?.throwIfAborted();
-		await fs.writeFile(this.authFilePath, `${JSON.stringify({ tokens: [] }, null, 2)}\n`, {
-			encoding: "utf8",
-			signal: this.signal
-		});
-		await this.clearAuthContext();
-		await this.credentialsStore.reloadCredentialsFromDisk();
-		this.signal?.throwIfAborted();
-	}
-	async clearTokensIfCurrent(tokens) {
-		this.signal?.throwIfAborted();
-		if (!tokensEqual(await this.getTokens(), tokens)) return;
-		await this.credentialsStore.deleteCredentials(tokens.workspaceId);
-		await this.removeRememberedWorkspace(tokens.workspaceId, { preserveActivePointer: true });
-		this.signal?.throwIfAborted();
-	}
-	async listWorkspaces() {
-		this.signal?.throwIfAborted();
-		const credentials = await this.readCredentialsFromDisk();
-		const context = await this.ensureMigratedAuthContext(credentials);
-		return this.workspacesFromState(credentials, context);
-	}
-	workspacesFromState(credentials, context) {
-		return credentials.map((credential) => storedCredentialToTokens(credential)).filter((tokens) => tokens !== null).map((tokens) => {
-			const cached = context.state.workspaces[tokens.workspaceId];
-			const id = typeof cached?.id === "string" && cached.id.trim().length > 0 ? cached.id.trim() : tokens.workspaceId;
-			const name = typeof cached?.name === "string" && cached.name.trim().length > 0 ? workspaceDisplayName(cached.name.trim(), tokens.workspaceId) : UNKNOWN_WORKSPACE_NAME;
-			const lastSeenAt = typeof cached?.lastSeenAt === "string" && cached.lastSeenAt.trim().length > 0 ? cached.lastSeenAt.trim() : null;
-			return {
-				id,
-				name,
-				credentialWorkspaceId: tokens.workspaceId,
-				active: context.state.activeWorkspaceId === tokens.workspaceId,
-				lastSeenAt
-			};
-		});
-	}
-	async listWorkspaceTokens() {
-		this.signal?.throwIfAborted();
-		return (await this.readCredentialsFromDisk()).map((credential) => storedCredentialToTokens(credential)).filter((tokens) => tokens !== null);
-	}
-	async useWorkspace(workspaceRef) {
-		return this.withRefreshLock(() => this.useWorkspaceUnlocked(workspaceRef));
-	}
-	/**
-	* Resolve a workspace ref (id, credential workspace id, or cached name)
-	* against the locally stored sessions without changing the active
-	* workspace. Read-only counterpart of useWorkspace: it reads the auth
-	* context as-is and never runs the legacy-state migration, so it writes
-	* nothing.
-	*/
-	async resolveWorkspace(workspaceRef) {
-		const ref = workspaceRef.trim();
-		if (!ref) throw new WorkspaceSelectionError("missing");
-		this.signal?.throwIfAborted();
-		const credentials = await this.readCredentialsFromDisk();
-		const context = await this.readAuthContext();
-		const matches = this.workspacesFromState(credentials, context).filter((workspace) => workspaceMatchesRef(workspace, ref));
-		if (matches.length === 0) throw new WorkspaceSelectionError("not-found", ref);
-		if (matches.length > 1) throw new WorkspaceSelectionError("ambiguous", ref, matches);
-		return matches[0];
-	}
-	async useWorkspaceUnlocked(workspaceRef) {
-		const ref = workspaceRef.trim();
-		if (!ref) throw new WorkspaceSelectionError("missing");
-		const workspaces = await this.listWorkspaces();
-		const context = await this.readAuthContext();
-		const previous = workspaces.find((workspace) => workspace.credentialWorkspaceId === context.state.activeWorkspaceId) ?? null;
-		const matches = workspaces.filter((workspace) => workspaceMatchesRef(workspace, ref));
-		if (matches.length === 0) throw new WorkspaceSelectionError("not-found", ref);
-		if (matches.length > 1) throw new WorkspaceSelectionError("ambiguous", ref, matches);
-		const selected = matches[0];
-		await this.setActiveWorkspaceId(selected.credentialWorkspaceId);
-		return {
-			previous,
-			selected
-		};
-	}
-	async logoutWorkspace(workspaceRef) {
-		return this.withRefreshLock(() => this.logoutWorkspaceUnlocked(workspaceRef));
-	}
-	async logoutWorkspaceUnlocked(workspaceRef) {
-		const ref = workspaceRef.trim();
-		if (!ref) throw new WorkspaceSelectionError("missing");
-		const workspaces = await this.listWorkspaces();
-		const context = await this.readAuthContext();
-		const matches = workspaces.filter((workspace) => workspaceMatchesRef(workspace, ref));
-		if (matches.length === 0) throw new WorkspaceSelectionError("not-found", ref);
-		if (matches.length > 1) throw new WorkspaceSelectionError("ambiguous", ref, matches);
-		const workspace = matches[0];
-		const wasActive = context.state.activeWorkspaceId === workspace.credentialWorkspaceId;
-		await this.credentialsStore.deleteCredentials(workspace.credentialWorkspaceId);
-		this.signal?.throwIfAborted();
-		const remainingWorkspaces = workspaces.filter((candidate) => candidate.credentialWorkspaceId !== workspace.credentialWorkspaceId);
-		if (remainingWorkspaces.length === 0) {
-			await this.clearAuthContext();
-			return {
-				workspace,
-				wasActive,
-				activeWorkspace: null
-			};
-		}
-		delete context.state.workspaces[workspace.credentialWorkspaceId];
-		if (wasActive) context.state.activeWorkspaceId = null;
-		await this.writeAuthContext(context.state);
-		return {
-			workspace,
-			wasActive,
-			activeWorkspace: context.state.activeWorkspaceId === null ? null : remainingWorkspaces.find((candidate) => candidate.credentialWorkspaceId === context.state.activeWorkspaceId) ?? null
-		};
-	}
-	async rememberWorkspace(credentialWorkspaceId, workspace) {
-		await this.withRefreshLock(() => this.rememberWorkspaceUnlocked(credentialWorkspaceId, workspace));
-	}
-	async rememberWorkspaceUnlocked(credentialWorkspaceId, workspace) {
-		const context = await this.readAuthContext();
-		context.state.workspaces[credentialWorkspaceId] = {
-			id: workspace.id,
-			name: workspace.name,
-			lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		await this.writeAuthContext(context.state);
-	}
-	async withRefreshLock(fn) {
-		const lockId = await this.acquireRefreshLock();
-		try {
-			return await fn();
-		} finally {
-			await this.releaseRefreshLock(lockId);
-		}
-	}
-	async acquireRefreshLock() {
-		const lockId = randomUUID();
-		const startedAt = Date.now();
-		const retryMs = this.options.lockRetryMs ?? REFRESH_LOCK_RETRY_MS;
-		const waitTimeoutMs = this.options.lockWaitTimeoutMs ?? REFRESH_LOCK_WAIT_TIMEOUT_MS;
-		this.signal?.throwIfAborted();
-		await fs.mkdir(path.dirname(this.lockFilePath), { recursive: true });
-		while (true) {
-			this.signal?.throwIfAborted();
-			if (await this.tryCreateRefreshLock(lockId)) return lockId;
-			if (await this.releaseStaleRefreshLock()) continue;
-			this.throwIfRefreshLockWaitTimedOut(startedAt, waitTimeoutMs);
-			await sleep(retryMs, this.signal);
-		}
-	}
-	async tryCreateRefreshLock(lockId) {
-		let lockFileCreated = false;
-		try {
-			const handle = await fs.open(this.lockFilePath, "wx");
-			lockFileCreated = true;
-			try {
-				this.signal?.throwIfAborted();
-				await handle.writeFile(lockId, { encoding: "utf8" });
-				this.signal?.throwIfAborted();
-			} finally {
-				await handle.close();
-			}
-			return true;
-		} catch (error) {
-			if (lockFileCreated) await fs.unlink(this.lockFilePath).catch(() => void 0);
-			if (error.code === "EEXIST") return false;
-			throw error;
-		}
-	}
-	async releaseStaleRefreshLock() {
-		const staleLockId = await this.getStaleRefreshLockId();
-		if (!staleLockId) return false;
-		await this.releaseRefreshLock(staleLockId);
-		return true;
-	}
-	throwIfRefreshLockWaitTimedOut(startedAt, waitTimeoutMs) {
-		if (Date.now() - startedAt < waitTimeoutMs) return;
-		throw new RefreshLockTimeoutError(this.lockFilePath, waitTimeoutMs);
-	}
-	async getStaleRefreshLockId() {
-		this.signal?.throwIfAborted();
-		const lockId = await fs.readFile(this.lockFilePath, {
-			encoding: "utf8",
-			signal: this.signal
-		}).catch((error) => {
-			if (this.signal?.aborted) throw error;
-			return null;
-		});
-		if (lockId === null) return null;
-		this.signal?.throwIfAborted();
-		const stats = await fs.stat(this.lockFilePath).catch(() => null);
-		this.signal?.throwIfAborted();
-		if (!stats) return null;
-		const staleMs = this.options.lockStaleMs ?? REFRESH_LOCK_STALE_MS;
-		return Date.now() - stats.mtimeMs > staleMs ? lockId : null;
-	}
-	async releaseRefreshLock(lockId) {
-		if (await fs.readFile(this.lockFilePath, { encoding: "utf8" }).catch(() => null) !== lockId) return;
-		await fs.unlink(this.lockFilePath).catch(() => {});
-	}
-	async readCredentialsFromDisk() {
-		this.signal?.throwIfAborted();
-		await this.credentialsStore.reloadCredentialsFromDisk();
-		this.signal?.throwIfAborted();
-		return await this.credentialsStore.getCredentials();
-	}
-	async ensureMigratedAuthContext(credentials) {
-		const context = await this.readAuthContext();
-		if (context.state.activeWorkspaceId || context.exists) return context;
-		const latest = findLatestValidTokens(credentials);
-		if (!latest) return context;
-		context.state.activeWorkspaceId = latest.workspaceId;
-		context.state.workspaces[latest.workspaceId] ??= {
-			id: latest.workspaceId,
-			name: latest.workspaceId,
-			lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		await this.writeAuthContext(context.state);
-		return {
-			exists: true,
-			state: context.state
-		};
-	}
-	async setActiveWorkspaceId(workspaceId) {
-		const context = await this.readAuthContext();
-		context.state.activeWorkspaceId = workspaceId;
-		context.state.workspaces[workspaceId] ??= {
-			id: workspaceId,
-			name: workspaceId,
-			lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		await this.writeAuthContext(context.state);
-	}
-	async maybeActivateWorkspaceId(workspaceId) {
-		if (this.options.pinnedWorkspaceId) return;
-		const context = await this.readAuthContext();
-		if (this.options.activateOnSetTokens === false && context.exists && context.state.activeWorkspaceId && context.state.activeWorkspaceId !== workspaceId) return;
-		context.state.activeWorkspaceId = workspaceId;
-		context.state.workspaces[workspaceId] ??= {
-			id: workspaceId,
-			name: workspaceId,
-			lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		await this.writeAuthContext(context.state);
-	}
-	async removeRememberedWorkspace(workspaceId, options) {
-		const context = await this.readAuthContext();
-		delete context.state.workspaces[workspaceId];
-		if (!options.preserveActivePointer && context.state.activeWorkspaceId === workspaceId) context.state.activeWorkspaceId = null;
-		await this.writeAuthContext(context.state);
-	}
-	async readAuthContext() {
-		this.signal?.throwIfAborted();
-		const raw = await fs.readFile(this.contextFilePath, {
-			encoding: "utf8",
-			signal: this.signal
-		}).catch((error) => {
-			if (this.signal?.aborted) throw error;
-			if (error.code === "ENOENT") return null;
-			throw error;
-		});
-		if (raw === null) return {
-			exists: false,
-			state: structuredClone(EMPTY_AUTH_CONTEXT)
-		};
-		try {
-			const parsed = JSON.parse(raw);
-			return {
-				exists: true,
-				state: {
-					activeWorkspaceId: typeof parsed.activeWorkspaceId === "string" && parsed.activeWorkspaceId.trim().length > 0 ? parsed.activeWorkspaceId.trim() : null,
-					workspaces: parsed.workspaces && typeof parsed.workspaces === "object" && !Array.isArray(parsed.workspaces) ? parsed.workspaces : {}
-				}
-			};
-		} catch {
-			return {
-				exists: false,
-				state: structuredClone(EMPTY_AUTH_CONTEXT)
-			};
-		}
-	}
-	async writeAuthContext(state) {
-		this.signal?.throwIfAborted();
-		await fs.mkdir(path.dirname(this.contextFilePath), { recursive: true });
-		this.signal?.throwIfAborted();
-		await fs.writeFile(this.contextFilePath, `${JSON.stringify(state, null, 2)}\n`, {
-			encoding: "utf8",
-			signal: this.signal
-		});
-		this.signal?.throwIfAborted();
-	}
-	async clearAuthContext() {
-		await fs.unlink(this.contextFilePath).catch((error) => {
-			if (error.code === "ENOENT") return;
-			throw error;
-		});
-	}
-};
-var WorkspaceSelectionError = class extends Error {
-	constructor(reason, workspaceRef, matches = []) {
-		super(reason);
-		this.reason = reason;
-		this.workspaceRef = workspaceRef;
-		this.matches = matches;
-		this.name = "WorkspaceSelectionError";
-	}
-};
-var RefreshLockTimeoutError = class extends Error {
-	constructor(lockFilePath, waitTimeoutMs) {
-		super(`Timed out waiting ${waitTimeoutMs}ms for auth refresh lock at ${lockFilePath}`);
-		this.name = "RefreshLockTimeoutError";
-	}
-};
-function workspaceMatchesRef(workspace, ref) {
-	return sameWorkspaceId(workspace.credentialWorkspaceId, ref) || sameWorkspaceId(workspace.id, ref) || workspace.name.toLowerCase() === ref.toLowerCase();
-}
-function workspaceDisplayName(name, credentialWorkspaceId) {
-	return name === credentialWorkspaceId ? UNKNOWN_WORKSPACE_NAME : name;
-}
-//#endregion
-export { FileTokenStorage, WorkspaceSelectionError };

package/dist/auth/workspaces.js

@@ -1,171 +0,0 @@
-import { CLIENT_ID, UNUSED_REDIRECT_URI, getApiBaseUrl } from "./client.js";
-import { FileTokenStorage, WorkspaceSelectionError } from "./token-storage.js";
-import { readAuthState } from "./operations.js";
-import { workspaceAmbiguousError, workspaceNotAuthenticatedError, workspaceSwitchUnavailableError } from "./errors.js";
-import { createManagementApiSdk } from "@prisma/management-api-sdk";
-import { SERVICE_TOKEN_ENV_VAR } from "@prisma/cli-engine";
-//#region src/auth/workspaces.ts
-async function listAuthWorkspaces(context) {
-	const rawServiceToken = context.env[SERVICE_TOKEN_ENV_VAR];
-	const storage = new FileTokenStorage(context.env, context.signal);
-	const localWorkspaces = await hydrateLocalAuthWorkspaces(context, storage, await storage.listWorkspaces());
-	if (rawServiceToken !== void 0) {
-		const authState = await readAuthState(context.env, context.signal);
-		return {
-			authSource: authState.authenticated ? "service_token" : "none",
-			activeWorkspace: authState.workspace,
-			workspaces: [...authState.workspace ? [{
-				...authState.workspace,
-				credentialWorkspaceId: null,
-				active: true,
-				source: "service_token",
-				switchable: false,
-				lastSeenAt: null
-			}] : [], ...localWorkspaces.map((workspace) => ({
-				...toAuthWorkspace(workspace),
-				credentialWorkspaceId: workspace.credentialWorkspaceId,
-				active: false,
-				source: "oauth",
-				switchable: false,
-				lastSeenAt: workspace.lastSeenAt
-			}))]
-		};
-	}
-	const active = localWorkspaces.find((workspace) => workspace.active) ?? null;
-	return {
-		authSource: localWorkspaces.length > 0 ? "oauth" : "none",
-		activeWorkspace: active ? toAuthWorkspace(active) : null,
-		workspaces: localWorkspaces.map((workspace) => ({
-			...toAuthWorkspace(workspace),
-			credentialWorkspaceId: workspace.credentialWorkspaceId,
-			active: workspace.active,
-			source: "oauth",
-			switchable: true,
-			lastSeenAt: workspace.lastSeenAt
-		}))
-	};
-}
-async function switchAuthWorkspace(context, workspaceRef) {
-	if (context.env[SERVICE_TOKEN_ENV_VAR] !== void 0) throw workspaceSwitchUnavailableError();
-	const storage = new FileTokenStorage(context.env, context.signal);
-	await hydrateLocalAuthWorkspaces(context, storage, await storage.listWorkspaces());
-	try {
-		const result = await storage.useWorkspace(workspaceRef);
-		return {
-			previousWorkspace: result.previous ? toAuthWorkspace(result.previous) : null,
-			workspace: toAuthWorkspace(result.selected)
-		};
-	} catch (error) {
-		if (error instanceof WorkspaceSelectionError) {
-			if (error.reason === "ambiguous") throw workspaceAmbiguousError(error.workspaceRef ?? workspaceRef, error.matches.map((match) => ({
-				id: match.id,
-				name: match.name,
-				credentialWorkspaceId: match.credentialWorkspaceId
-			})));
-			throw workspaceNotAuthenticatedError(error.workspaceRef ?? workspaceRef);
-		}
-		throw error;
-	}
-}
-async function logoutAuthWorkspace(context, workspaceRef) {
-	const storage = new FileTokenStorage(context.env, context.signal);
-	await hydrateLocalAuthWorkspaces(context, storage, await storage.listWorkspaces());
-	try {
-		const result = await storage.logoutWorkspace(workspaceRef);
-		return {
-			workspace: toAuthWorkspace(result.workspace),
-			wasActive: result.wasActive,
-			activeWorkspace: result.activeWorkspace ? toAuthWorkspace(result.activeWorkspace) : null
-		};
-	} catch (error) {
-		if (error instanceof WorkspaceSelectionError) {
-			if (error.reason === "ambiguous") throw workspaceAmbiguousError(error.workspaceRef ?? workspaceRef, error.matches.map((match) => ({
-				id: match.id,
-				name: match.name,
-				credentialWorkspaceId: match.credentialWorkspaceId
-			})));
-			throw workspaceNotAuthenticatedError(error.workspaceRef ?? workspaceRef);
-		}
-		throw error;
-	}
-}
-async function hydrateLocalAuthWorkspaces(context, storage, workspaces) {
-	const candidates = workspaces.filter(needsWorkspaceMetadataHydration);
-	if (candidates.length === 0) return workspaces;
-	const tokensByCredentialWorkspaceId = new Map((await storage.listWorkspaceTokens()).map((tokens) => [tokens.workspaceId, tokens]));
-	let nextWorkspaces = workspaces;
-	for (const workspace of candidates) {
-		const tokens = tokensByCredentialWorkspaceId.get(workspace.credentialWorkspaceId);
-		if (!tokens) continue;
-		const resolved = await resolveOAuthWorkspaceMetadata(context, tokens);
-		if (!resolved) continue;
-		await rememberResolvedWorkspaceMetadata(context, storage, tokens, resolved);
-		nextWorkspaces = nextWorkspaces.map((candidate) => candidate.credentialWorkspaceId === workspace.credentialWorkspaceId ? {
-			...candidate,
-			id: resolved.id,
-			name: resolved.name,
-			lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
-		} : candidate);
-	}
-	return nextWorkspaces;
-}
-async function rememberResolvedWorkspaceMetadata(context, storage, tokens, resolved) {
-	try {
-		await storage.rememberWorkspace(tokens.workspaceId, resolved);
-	} catch {
-		context.signal?.throwIfAborted();
-	}
-}
-function needsWorkspaceMetadataHydration(workspace) {
-	return workspace.id === workspace.credentialWorkspaceId || workspace.name === "Unknown workspace" || workspace.name === workspace.credentialWorkspaceId;
-}
-async function resolveOAuthWorkspaceMetadata(context, tokens) {
-	const sdk = createManagementApiSdk({
-		clientId: CLIENT_ID,
-		redirectUri: UNUSED_REDIRECT_URI,
-		tokenStorage: createSingleWorkspaceTokenStorage(new FileTokenStorage(context.env, context.signal, { activateOnSetTokens: false }), tokens),
-		apiBaseUrl: getApiBaseUrl(context.env)
-	});
-	try {
-		const { data } = await sdk.client.GET("/v1/workspaces/{id}", {
-			params: { path: { id: tokens.workspaceId } },
-			signal: context.signal
-		});
-		const id = stringOrNull(data?.data?.id) ?? tokens.workspaceId;
-		const name = stringOrNull(data?.data?.name) ?? id;
-		if (id === tokens.workspaceId && name === tokens.workspaceId) return null;
-		return {
-			id,
-			name
-		};
-	} catch {
-		context.signal?.throwIfAborted();
-		return null;
-	}
-}
-function createSingleWorkspaceTokenStorage(storage, initialTokens) {
-	let currentTokens = initialTokens;
-	return {
-		getTokens: async () => currentTokens,
-		setTokens: async (tokens) => {
-			currentTokens = tokens;
-			await storage.setTokens(tokens);
-		},
-		clearTokens: async () => {
-			const tokens = currentTokens;
-			currentTokens = null;
-			if (tokens) await storage.clearTokensIfCurrent(tokens);
-		}
-	};
-}
-function stringOrNull(value) {
-	return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
-}
-function toAuthWorkspace(workspace) {
-	return {
-		id: workspace.id,
-		name: workspace.name
-	};
-}
-//#endregion
-export { listAuthWorkspaces, logoutAuthWorkspace, switchAuthWorkspace };

package/dist/cli-command.js

@@ -1,14 +0,0 @@
-//#region src/cli-command.ts
-const PRISMA_CLI_PACKAGE_NAME = "@prisma/cli";
-const PRISMA_CLI_PACKAGE_SPEC = `${PRISMA_CLI_PACKAGE_NAME}@latest`;
-const DEFAULT_PRISMA_CLI_PACKAGE_RUNNER = ["npx", "-y"];
-const PRISMA_CLI_BINARY = "prisma-cli";
-function formatPrismaCliCommand(args, options = {}) {
-	return [...getPrismaCliCommandPrefix(options), ...args].join(" ");
-}
-function getPrismaCliCommandPrefix({ invocation = "package", packageRunner = DEFAULT_PRISMA_CLI_PACKAGE_RUNNER }) {
-	if (invocation === "binary") return [PRISMA_CLI_BINARY];
-	return [...packageRunner, PRISMA_CLI_PACKAGE_SPEC];
-}
-//#endregion
-export { DEFAULT_PRISMA_CLI_PACKAGE_RUNNER, PRISMA_CLI_BINARY, PRISMA_CLI_PACKAGE_NAME, PRISMA_CLI_PACKAGE_SPEC, formatPrismaCliCommand };

package/dist/cli-name.js

@@ -1,12 +0,0 @@
-//#region src/cli-name.ts
-/**
-* The CLI's user-facing identity, in one place. The npm package is
-* "@prisma/cli" but the binary on PATH is "prisma-cli" (the S1
-* convention) — every user-facing command string and notice consumes
-* this constant rather than restating the name.
-*/
-const CLI_NAME = "prisma-cli";
-/** The CLI docs page (also the update-check fallback instruction URL). */
-const CLI_DOCS_URL = "https://www.prisma.io/docs/orm/tools/prisma-cli";
-//#endregion
-export { CLI_DOCS_URL, CLI_NAME };