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

package/dist/shell/prompt.js

@@ -1,6 +1,7 @@
 import { usageError } from "./errors.js";
 import { confirm, isCancel, select, text } from "@clack/prompts";
 //#region src/shell/prompt.ts
+const PROMPT_CANCELED_SUMMARY = "Interactive prompt canceled";
 async function selectPrompt(options) {
 	const promptOptions = options.choices.map((choice) => ({
 		label: choice.label,
@@ -9,31 +10,34 @@ async function selectPrompt(options) {
 	const response = await select({
 		input: options.input,
 		output: options.output,
+		signal: options.signal,
 		message: options.message,
 		options: promptOptions
 	});
-	if (isCancel(response)) throw usageError("Interactive prompt canceled", "The command was canceled before a selection was made.", "Re-run the command and choose an option to continue.");
+	if (isCancel(response)) throw usageError(PROMPT_CANCELED_SUMMARY, "The command was canceled before a selection was made.", "Re-run the command and choose an option to continue.");
 	return response;
 }
 async function textPrompt(options) {
 	const response = await text({
 		input: options.input,
 		output: options.output,
+		signal: options.signal,
 		message: options.message,
 		placeholder: options.placeholder,
 		validate: options.validate
 	});
-	if (isCancel(response)) throw usageError("Interactive prompt canceled", "The command was canceled before a value was entered.", "Re-run the command and provide a value to continue.");
+	if (isCancel(response)) throw usageError(PROMPT_CANCELED_SUMMARY, "The command was canceled before a value was entered.", "Re-run the command and provide a value to continue.");
 	return response;
 }
 async function confirmPrompt(options) {
 	const response = await confirm({
 		input: options.input,
 		output: options.output,
+		signal: options.signal,
 		message: options.message,
 		initialValue: options.initialValue ?? false
 	});
-	if (isCancel(response)) throw usageError("Interactive prompt canceled", "The command was canceled before a confirmation was made.", "Re-run the command and choose an option to continue.");
+	if (isCancel(response)) throw usageError(PROMPT_CANCELED_SUMMARY, "The command was canceled before a confirmation was made.", "Re-run the command and choose an option to continue.");
 	return response;
 }
 function disposePromptState(_input) {}

package/dist/shell/runtime.js

@@ -3,6 +3,7 @@ import { LocalStateStore } from "../adapters/local-state.js";
 import { MockApi } from "../adapters/mock-api.js";
 import { renderHelp } from "./help.js";
 import path from "node:path";
+import { findComputeConfigDir } from "@prisma/compute-sdk/config";
 //#region src/shell/runtime.ts
 const DEFAULT_STATE_DIR_NAME = path.join(".prisma", "cli");
 function configureRuntimeCommand(command, runtime) {
@@ -20,15 +21,15 @@ function configureRuntimeCommand(command, runtime) {
 }
 async function createCommandContext(runtime, flags) {
 	const fixturePath = runtime.fixturePath ?? runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
-	const stateDir = resolveStateDir(runtime);
+	const stateDir = await 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
@@ -38,8 +39,11 @@ async function createCommandContext(runtime, flags) {
 		ui: createShellUi(runtime, flags)
 	};
 }
-function resolveStateDir(runtime) {
-	return runtime.stateDir ?? runtime.env.PRISMA_CLI_STATE_DIR ?? path.join(runtime.cwd, DEFAULT_STATE_DIR_NAME);
+async function resolveStateDir(runtime) {
+	const explicitStateDir = runtime.stateDir ?? runtime.env.PRISMA_CLI_STATE_DIR;
+	if (explicitStateDir) return explicitStateDir;
+	const projectDir = await findComputeConfigDir(runtime.cwd, runtime.signal);
+	return path.join(projectDir ?? runtime.cwd, DEFAULT_STATE_DIR_NAME);
 }
 function canPrompt(context) {
 	if (context.flags.json) return false;
@@ -48,4 +52,4 @@ function canPrompt(context) {
 	return Boolean(context.runtime.stdin.isTTY && context.runtime.stderr.isTTY);
 }
 //#endregion
-export { canPrompt, configureRuntimeCommand, createCommandContext };
+export { canPrompt, configureRuntimeCommand, createCommandContext, resolveStateDir };

package/dist/shell/ui.js

@@ -1,8 +1,9 @@
+import { createColors } from "colorette";
 import stringWidth from "string-width";
 import stripAnsi from "strip-ansi";
 import wrapAnsi from "wrap-ansi";
-import { createColors } from "colorette";
 //#region src/shell/ui.ts
+const URL_CREDENTIALS_PATTERN = /:\/\/[^:@/\s]+:[^@/\s]+@/g;
 const DEFAULT_WIDTH = 80;
 function createShellUi(runtime, flags) {
 	const isTTY = Boolean(runtime.stderr.isTTY);
@@ -48,6 +49,20 @@ function renderNextSteps(steps) {
 		...steps.map((step) => `- ${step}`)
 	];
 }
+function renderVerboseBlock(ui, rows, options = {}) {
+	if (!ui.verbose || rows.length === 0) return [];
+	const title = options.title ?? "Details";
+	const keyWidth = Math.max(...rows.map((row) => stringWidth(`${row.key}:`)));
+	const rail = ui.dim("│");
+	return [
+		"",
+		`${ui.dim(title)}:`,
+		...rows.map((row) => `${rail}  ${ui.accent(padDisplay(`${row.key}:`, keyWidth))}  ${formatVerboseValue(ui, row)}`)
+	];
+}
+function formatColumns(columns, widths) {
+	return columns.map((value, index) => padDisplay(value, widths[index])).join("   ").trimEnd();
+}
 function wrapText(text, width, indent = "") {
 	return wrapAnsi(text, width, {
 		hard: false,
@@ -59,7 +74,23 @@ function padDisplay(text, width) {
 	return `${text}${" ".repeat(padding)}`;
 }
 function maskValue(value) {
-	return value.replace(/([A-Za-z0-9._%+-]{1,})(?=@)/g, "****").replace(/:\/\/[^:@/\s]+:[^@/\s]+@/g, "://****:****@");
+	return maskEmailLocalParts(value).replace(URL_CREDENTIALS_PATTERN, "://****:****@");
+}
+function maskEmailLocalParts(value) {
+	let masked = "";
+	let segmentStart = 0;
+	for (let index = 0; index < value.length; index += 1) {
+		if (value[index] !== "@") continue;
+		let localStart = index;
+		while (localStart > segmentStart && isEmailLocalPartChar(value[localStart - 1])) localStart -= 1;
+		if (localStart === index) continue;
+		masked += `${value.slice(segmentStart, localStart)}****@`;
+		segmentStart = index + 1;
+	}
+	return masked + value.slice(segmentStart);
+}
+function isEmailLocalPartChar(char) {
+	return char >= "A" && char <= "Z" || char >= "a" && char <= "z" || char >= "0" && char <= "9" || char === "!" || char === "#" || char === "$" || char === "." || char === "&" || char === "'" || char === "*" || char === "%" || char === "+" || char === "-" || char === "/" || char === "=" || char === "?" || char === "^" || char === "_" || char === "`" || char === "{" || char === "|" || char === "}" || char === "~";
 }
 function resolveColorEnabled(runtime, flags, isTTY) {
 	if (flags.color === true) return true;
@@ -73,5 +104,13 @@ function formatHeaderValue(ui, row) {
 	if (row.tone === "link") return ui.link(value);
 	return value;
 }
+function formatVerboseValue(ui, row) {
+	const value = row.sensitive ? maskValue(row.value) : row.value;
+	if (row.tone === "dim") return ui.dim(value);
+	if (row.tone === "success") return ui.success(value);
+	if (row.tone === "warning") return ui.warning(value);
+	if (row.tone === "link") return ui.link(value);
+	return value;
+}
 //#endregion
-export { createShellUi, maskValue, padDisplay, renderCommandHeader, renderNextSteps, renderSummaryLine, wrapText };
+export { createShellUi, formatColumns, maskValue, padDisplay, renderCommandHeader, renderNextSteps, renderSummaryLine, renderVerboseBlock, wrapText };

package/dist/shell/update-check.js

@@ -0,0 +1,247 @@
+import { getCliName, getCliVersion } from "../lib/version.js";
+import path from "node:path";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+//#region src/shell/update-check.ts
+const UPDATE_CHECK_FILE_NAME = "update-check.json";
+const FALLBACK_INSTALL_DOCS_URL = "https://www.prisma.io/docs/orm/tools/prisma-cli";
+const NOTIFICATION_INTERVAL_MS = 1440 * 60 * 1e3;
+const REGISTRY_URL = "https://registry.npmjs.org/@prisma%2fcli";
+const REGISTRY_TIMEOUT_MS = 3e3;
+var UpdateCheckStore = class {
+	filePath;
+	constructor(cacheDir) {
+		this.filePath = path.join(cacheDir, UPDATE_CHECK_FILE_NAME);
+	}
+	async read() {
+		try {
+			return JSON.parse(await readFile(this.filePath, "utf8"));
+		} catch (error) {
+			if (isUnreadableCacheError(error)) return null;
+			throw error;
+		}
+	}
+	async write(state) {
+		const dir = path.dirname(this.filePath);
+		const tempPath = path.join(dir, `${UPDATE_CHECK_FILE_NAME}.${process.pid}.${randomUUID()}.tmp`);
+		await mkdir(dir, { recursive: true });
+		await writeFile(tempPath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+		await rename(tempPath, this.filePath);
+	}
+};
+async function maybeWriteCachedUpdateNotification(runtime) {
+	if (!canRunUpdateCheck(runtime)) return;
+	try {
+		const cacheDir = resolveUpdateCheckCacheDir(runtime);
+		const store = new UpdateCheckStore(cacheDir);
+		const state = await store.read();
+		const latestVersion = state?.latestVersion;
+		if (latestVersion && isInstalledVersionStale(getCliVersion(), latestVersion) && shouldNotify(state)) {
+			runtime.stderr.write(renderUpdateNotification(latestVersion, selectUpdateInstruction(runtime.env)));
+			await store.write({
+				...state,
+				packageName: "@prisma/cli",
+				installedVersion: getCliVersion(),
+				notifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		}
+		await scheduleRemoteDiscovery(runtime, store, state, cacheDir);
+	} catch {
+		return;
+	}
+}
+async function runUpdateDiscovery(options) {
+	try {
+		const latestVersion = await fetchLatestVersion(options.registryUrl ?? REGISTRY_URL, options.fetchImpl ?? fetch);
+		if (!latestVersion) return;
+		const store = new UpdateCheckStore(options.cacheDir);
+		const previousState = await store.read();
+		await store.write({
+			...previousState,
+			packageName: "@prisma/cli",
+			installedVersion: options.installedVersion,
+			latestVersion,
+			checkedAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString()
+		});
+	} catch {
+		return;
+	}
+}
+function isUnreadableCacheError(error) {
+	const code = error.code;
+	return code === "ENOENT" || code === "EACCES" || code === "EPERM" || error instanceof SyntaxError;
+}
+async function runUpdateDiscoveryWorker(env = process.env) {
+	const cacheDir = env.PRISMA_CLI_UPDATE_CHECK_DIR;
+	const installedVersion = env.PRISMA_CLI_UPDATE_CHECK_INSTALLED_VERSION;
+	if (!cacheDir || !installedVersion) return;
+	await runUpdateDiscovery({
+		cacheDir,
+		installedVersion,
+		registryUrl: env.PRISMA_CLI_UPDATE_CHECK_REGISTRY_URL
+	});
+}
+function canRunUpdateCheck(runtime) {
+	if (runtime.env.NO_UPDATE_NOTIFIER !== void 0) return false;
+	if (isTestRuntime(runtime.env) && runtime.env.PRISMA_CLI_TEST_ENABLE_UPDATE_CHECK !== "1") return false;
+	if (runtime.env.CI || runtime.env.GITHUB_ACTIONS) return false;
+	if (!runtime.stderr.isTTY) return false;
+	if (runtime.argv.includes("--json") || runtime.argv.includes("--quiet") || runtime.argv.includes("-q")) return false;
+	if (runtime.argv.includes("--version")) return false;
+	return true;
+}
+function shouldNotify(state) {
+	return !state.notifiedAt || isAtLeastIntervalAgo(state.notifiedAt);
+}
+async function scheduleRemoteDiscovery(runtime, store, state, cacheDir) {
+	if (state?.checkedAt && !isAtLeastIntervalAgo(state.checkedAt)) return;
+	const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+	await store.write({
+		...state,
+		packageName: "@prisma/cli",
+		installedVersion: getCliVersion(),
+		checkedAt
+	});
+	if (isTestRuntime(runtime.env)) return;
+	const entrypoint = process.argv[1];
+	if (!entrypoint) return;
+	spawn(process.execPath, [entrypoint], {
+		detached: true,
+		stdio: "ignore",
+		env: {
+			...process.env,
+			PRISMA_CLI_RUN_UPDATE_CHECK_WORKER: "1",
+			PRISMA_CLI_UPDATE_CHECK_DIR: cacheDir,
+			PRISMA_CLI_UPDATE_CHECK_INSTALLED_VERSION: getCliVersion(),
+			PRISMA_CLI_UPDATE_CHECK_REGISTRY_URL: runtime.env.PRISMA_CLI_UPDATE_CHECK_REGISTRY_URL ?? REGISTRY_URL
+		}
+	}).unref();
+}
+function selectUpdateInstruction(env, processArgv = process.argv) {
+	const entrypoint = (processArgv[1] ?? "").replace(/\\/g, "/").toLowerCase();
+	const userAgent = env.npm_config_user_agent?.toLowerCase() ?? "";
+	if (isEphemeralInvocation(entrypoint, env.npm_lifecycle_event?.toLowerCase() ?? "")) return docsInstruction();
+	if (entrypoint.includes("/node_modules/.bin/")) {
+		if (userAgent.startsWith("pnpm")) return commandInstruction("pnpm add -D @prisma/cli@latest");
+		if (userAgent.startsWith("bun")) return commandInstruction("bun add -d @prisma/cli@latest");
+		if (userAgent.startsWith("npm")) return commandInstruction("npm install --save-dev @prisma/cli@latest");
+	}
+	if (env.npm_config_global === "true" || isLikelyGlobalNpmEntrypoint(entrypoint)) return commandInstruction("npm install --global @prisma/cli@latest");
+	return docsInstruction();
+}
+function renderUpdateNotification(latestVersion, instruction) {
+	return [
+		`Update available: ${getCliName()} ${getCliVersion()} -> ${latestVersion}`,
+		renderUpdateInstruction(instruction),
+		""
+	].join("\n");
+}
+function renderUpdateInstruction(instruction) {
+	if (instruction.type === "command") return `Run ${instruction.value} to update.`;
+	return `See ${instruction.value} for update instructions.`;
+}
+function isEphemeralInvocation(entrypoint, lifecycle) {
+	return lifecycle === "npx" || lifecycle === "pnpx" || entrypoint.includes("/_npx/") || entrypoint.includes("/.bun/");
+}
+function isLikelyGlobalNpmEntrypoint(entrypoint) {
+	return /\/npm\/prisma-cli(\.cmd|\.exe)?$/.test(entrypoint) || /\/npm-global\/bin\/prisma-cli$/.test(entrypoint);
+}
+function commandInstruction(value) {
+	return {
+		type: "command",
+		value
+	};
+}
+function docsInstruction() {
+	return {
+		type: "docs",
+		value: FALLBACK_INSTALL_DOCS_URL
+	};
+}
+function resolveUpdateCheckCacheDir(runtime) {
+	const configured = runtime.env.PRISMA_CLI_UPDATE_CHECK_DIR;
+	if (configured?.trim()) return path.resolve(configured);
+	if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Caches", "prisma-cli");
+	if (process.platform === "win32") {
+		const localAppData = runtime.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local");
+		return path.join(localAppData, "prisma-cli", "cache");
+	}
+	const xdgCacheHome = runtime.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache");
+	return path.join(xdgCacheHome, "prisma-cli");
+}
+function isTestRuntime(env) {
+	return env.VITEST !== void 0 || env.NODE_ENV === "test";
+}
+function isAtLeastIntervalAgo(value) {
+	const timestamp = Date.parse(value);
+	return Number.isNaN(timestamp) || Date.now() - timestamp >= NOTIFICATION_INTERVAL_MS;
+}
+function isInstalledVersionStale(installedVersion, latestVersion) {
+	const installed = parseVersion(installedVersion);
+	const latest = parseVersion(latestVersion);
+	if (!installed || !latest) return false;
+	return compareVersions(installed, latest) < 0;
+}
+function parseVersion(version) {
+	const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(version);
+	if (!match) return null;
+	return {
+		major: Number(match[1]),
+		minor: Number(match[2]),
+		patch: Number(match[3]),
+		prerelease: match[4]?.split(".") ?? []
+	};
+}
+function compareVersions(left, right) {
+	for (const key of [
+		"major",
+		"minor",
+		"patch"
+	]) {
+		const diff = left[key] - right[key];
+		if (diff !== 0) return diff;
+	}
+	return comparePrerelease(left.prerelease, right.prerelease);
+}
+function comparePrerelease(left, right) {
+	if (left.length === 0 && right.length === 0) return 0;
+	if (left.length === 0) return 1;
+	if (right.length === 0) return -1;
+	const count = Math.max(left.length, right.length);
+	for (let index = 0; index < count; index += 1) {
+		const leftPart = left[index];
+		const rightPart = right[index];
+		if (leftPart === void 0) return -1;
+		if (rightPart === void 0) return 1;
+		const diff = comparePrereleasePart(leftPart, rightPart);
+		if (diff !== 0) return diff;
+	}
+	return 0;
+}
+function comparePrereleasePart(left, right) {
+	const leftNumber = /^\d+$/.test(left) ? Number(left) : null;
+	const rightNumber = /^\d+$/.test(right) ? Number(right) : null;
+	if (leftNumber !== null && rightNumber !== null) return leftNumber - rightNumber;
+	if (leftNumber !== null) return -1;
+	if (rightNumber !== null) return 1;
+	return left.localeCompare(right);
+}
+async function fetchLatestVersion(registryUrl, fetchImpl) {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), REGISTRY_TIMEOUT_MS);
+	try {
+		const response = await fetchImpl(registryUrl, {
+			signal: controller.signal,
+			headers: { accept: "application/json" }
+		});
+		if (!response.ok) return null;
+		const latest = (await response.json())["dist-tags"]?.latest;
+		return typeof latest === "string" ? latest : null;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+//#endregion
+export { maybeWriteCachedUpdateNotification, runUpdateDiscoveryWorker };

package/dist/use-cases/auth.js

@@ -1,4 +1,4 @@
-import { usageError } from "../shell/errors.js";
+import { authRequiredError, usageError, workspaceAmbiguousError, workspaceNotAuthenticatedError } from "../shell/errors.js";
 //#region src/use-cases/auth.ts
 function createAuthUseCases(dependencies) {
 	return {
@@ -15,6 +15,70 @@ function createAuthUseCases(dependencies) {
 			await dependencies.sessionGateway.clearAuthSession();
 			return resolveCurrentAuthState(dependencies);
 		},
+		listWorkspaces: async () => {
+			const session = await dependencies.sessionGateway.readAuthSession();
+			if (!session) return {
+				authSource: "none",
+				activeWorkspace: null,
+				workspaces: []
+			};
+			const workspaces = dependencies.identityGateway.listUserWorkspaces(session.userId);
+			return {
+				authSource: "oauth",
+				activeWorkspace: workspaces.find((workspace) => workspace.id === session.workspaceId) ?? null,
+				workspaces: workspaces.map((workspace) => ({
+					...workspace,
+					credentialWorkspaceId: workspace.id,
+					active: workspace.id === session.workspaceId,
+					source: "oauth",
+					switchable: true,
+					lastSeenAt: null
+				}))
+			};
+		},
+		useWorkspace: async (workspaceRef) => {
+			const session = await dependencies.sessionGateway.readAuthSession();
+			if (!session) throw authRequiredError(["prisma-cli auth login"]);
+			const ref = workspaceRef.trim();
+			const matches = dependencies.identityGateway.listUserWorkspaces(session.userId).filter((workspace) => workspaceMatchesRef(workspace, ref));
+			if (matches.length === 0) throw workspaceNotAuthenticatedError(workspaceRef);
+			if (matches.length > 1) throw workspaceAmbiguousError(workspaceRef, matches.map((workspace) => ({
+				id: workspace.id,
+				name: workspace.name,
+				credentialWorkspaceId: workspace.id
+			})));
+			const selected = matches[0];
+			const previousWorkspace = dependencies.identityGateway.getWorkspace(session.workspaceId) ?? null;
+			await dependencies.sessionGateway.writeAuthSession({
+				...session,
+				workspaceId: selected.id
+			});
+			return {
+				previousWorkspace,
+				workspace: selected
+			};
+		},
+		logoutWorkspace: async (workspaceRef) => {
+			const session = await dependencies.sessionGateway.readAuthSession();
+			if (!session) throw workspaceNotAuthenticatedError(workspaceRef);
+			const ref = workspaceRef.trim();
+			const matches = dependencies.identityGateway.listUserWorkspaces(session.userId).filter((workspace) => workspaceMatchesRef(workspace, ref));
+			if (matches.length === 0) throw workspaceNotAuthenticatedError(workspaceRef);
+			if (matches.length > 1) throw workspaceAmbiguousError(workspaceRef, matches.map((workspace) => ({
+				id: workspace.id,
+				name: workspace.name,
+				credentialWorkspaceId: workspace.id
+			})));
+			const workspace = matches[0];
+			const wasActive = workspace.id === session.workspaceId;
+			const activeWorkspace = wasActive ? null : dependencies.identityGateway.getWorkspace(session.workspaceId) ?? null;
+			if (wasActive) await dependencies.sessionGateway.clearAuthSession();
+			return {
+				workspace,
+				wasActive,
+				activeWorkspace
+			};
+		},
 		listProviders: async () => dependencies.identityGateway.listProviders(),
 		resolveProvider: async (providerId) => {
 			const provider = dependencies.identityGateway.getProvider(providerId);
@@ -39,6 +103,9 @@ function createAuthUseCases(dependencies) {
 		}
 	};
 }
+function workspaceMatchesRef(workspace, ref) {
+	return workspace.id === ref || workspace.name.toLowerCase() === ref.toLowerCase();
+}
 async function resolveCurrentAuthState(dependencies) {
 	const session = await dependencies.sessionGateway.readAuthSession();
 	if (!session) return {

package/dist/use-cases/branch.js

@@ -1,34 +1,19 @@
 //#region src/use-cases/branch.ts
 function createBranchUseCases(dependencies) {
-	return {
-		list: async () => {
-			const [projectId, activeBranch] = await Promise.all([dependencies.projectStateGateway.readRememberedProjectId(), dependencies.branchStateGateway.readActiveBranch()]);
-			const remoteBranches = await listRemoteBranches(dependencies.branchGateway, projectId);
-			return {
-				projectId,
-				projectName: resolveProjectName(dependencies.projectGateway, projectId),
-				activeBranch,
-				branches: buildBranchSummaries(activeBranch, remoteBranches)
-			};
-		},
-		show: async () => {
-			const [projectId, activeBranch] = await Promise.all([dependencies.projectStateGateway.readRememberedProjectId(), dependencies.branchStateGateway.readActiveBranch()]);
-			return {
-				projectId,
-				projectName: resolveProjectName(dependencies.projectGateway, projectId),
-				branch: buildBranchDetail(dependencies.branchGateway, projectId, activeBranch)
-			};
-		},
-		use: async (branchName) => {
-			await dependencies.branchStateGateway.writeActiveBranch(branchName);
-			const projectId = await dependencies.projectStateGateway.readRememberedProjectId();
-			return {
-				projectId,
-				projectName: resolveProjectName(dependencies.projectGateway, projectId),
-				branch: buildBranchDetail(dependencies.branchGateway, projectId, branchName)
-			};
-		}
-	};
+	return { list: async () => {
+		const projectId = await dependencies.projectStateGateway.readRememberedProjectId();
+		if (!projectId) return {
+			projectId: "",
+			projectName: "not resolved",
+			branches: []
+		};
+		const remoteBranches = await listRemoteBranches(dependencies.branchGateway, projectId);
+		return {
+			projectId,
+			projectName: resolveProjectName(dependencies.projectGateway, projectId) ?? "not resolved",
+			branches: buildBranchSummaries(remoteBranches)
+		};
+	} };
 }
 function resolveProjectName(projectGateway, projectId) {
 	if (!projectId) return null;
@@ -38,38 +23,13 @@ async function listRemoteBranches(branchGateway, projectId) {
 	if (!projectId) return [];
 	return branchGateway.listBranchesForProject(projectId);
 }
-function buildBranchSummaries(activeBranch, remoteBranches) {
-	const byName = /* @__PURE__ */ new Map();
-	for (const branch of remoteBranches) byName.set(branch.name, {
+function buildBranchSummaries(remoteBranches) {
+	return sortBranches(remoteBranches.map((branch) => ({
 		id: branch.id,
 		name: branch.name,
-		kind: branch.kind,
-		active: activeBranch === branch.name,
-		remoteState: true
-	});
-	if (!byName.has(activeBranch)) byName.set(activeBranch, {
-		id: activeBranch,
-		name: activeBranch,
-		kind: toBranchKind(activeBranch),
-		active: true,
-		remoteState: false
-	});
-	return sortBranches([...byName.values()]);
-}
-function buildBranchDetail(branchGateway, projectId, branchName) {
-	const kind = toBranchKind(branchName);
-	const remoteBranch = projectId ? branchGateway.getBranchForProject(projectId, branchName) : void 0;
-	return {
-		name: branchName,
-		kind,
-		active: true,
-		remoteState: Boolean(remoteBranch),
-		liveDeployment: remoteBranch && remoteBranch.currentDeploymentId ? toLiveDeployment(branchGateway.getDeployment(remoteBranch.currentDeploymentId)) : null
-	};
-}
-function toBranchKind(name) {
-	if (name === "production") return "production";
-	return "preview";
+		role: branch.role,
+		envMap: branch.role
+	})));
 }
 function sortBranches(branches) {
 	return branches.slice().sort((left, right) => {
@@ -80,16 +40,8 @@ function sortBranches(branches) {
 	});
 }
 function branchOrder(branch) {
-	if (branch.name === "production") return 0;
+	if (branch.role === "production") return 0;
 	return 1;
 }
-function toLiveDeployment(deployment) {
-	if (!deployment) return null;
-	return {
-		id: deployment.id,
-		status: deployment.status,
-		url: deployment.url
-	};
-}
 //#endregion
 export { createBranchUseCases };

package/dist/use-cases/create-cli-gateways.js

@@ -29,16 +29,9 @@ function createCliUseCaseGateways(context) {
 			getProjectForWorkspace: (workspaceId, projectId) => context.api.getProjectForWorkspace(workspaceId, projectId)
 		},
 		branchGateway: {
-			listBranchesForProject: (projectId) => context.api.listBranchesForProject(projectId).map((branch) => ({
-				...branch,
-				kind: branch.name === "production" ? "production" : "preview"
-			})),
+			listBranchesForProject: (projectId) => context.api.listBranchesForProject(projectId),
 			getBranchForProject: (projectId, name) => {
-				const branch = context.api.getBranchForProject(projectId, name);
-				return branch ? {
-					...branch,
-					kind: branch.name === "production" ? "production" : "preview"
-				} : void 0;
+				return context.api.getBranchForProject(projectId, name);
 			},
 			getDeployment: (deploymentId) => context.api.getDeployment(deploymentId)
 		},
@@ -55,14 +48,6 @@ function createCliUseCaseGateways(context) {
 			clearAuthSession: async () => {
 				await context.stateStore.clearAuthSession();
 			}
-		},
-		branchStateGateway: {
-			readActiveBranch: async () => {
-				return (await context.stateStore.read()).branch.active;
-			},
-			writeActiveBranch: async (branchName) => {
-				await context.stateStore.setActiveBranch(branchName);
-			}
 		}
 	};
 }