@prisma/cli 3.0.0-beta.1 → 3.0.0-beta.10

package/dist/shell/command-runner.js

@@ -1,19 +1,27 @@
-import { CliError, authRequiredError } from "./errors.js";
+import { CliError, authRequiredError, commandCanceledError } from "./errors.js";
 import { cliErrorToJson, writeHumanError, writeHumanLines, writeJsonError, writeJsonEvent, writeJsonSuccess } from "./output.js";
 import { getCommandDescriptor } from "./command-meta.js";
 import { resolveGlobalFlags } from "./global-flags.js";
 import { createCommandContext } from "./runtime.js";
+import { collectCommandDiagnostics } from "../lib/diagnostics.js";
+import { renderCommandDiagnostics } from "./diagnostics-output.js";
 import { AuthError } from "@prisma/management-api-sdk";
 //#region src/shell/command-runner.ts
-function toCliError(error) {
+function toCliError(error, runtime) {
+	if (isCancellationError(error) || runtime.signal.aborted) return commandCanceledError();
 	if (error instanceof CliError) return error;
 	if (error instanceof AuthError) return authRequiredError(["prisma-cli auth login"], { debug: error.message });
 	return null;
 }
+function isCancellationError(error) {
+	if (!(error instanceof Error)) return false;
+	return error.name === "AbortError" || error.name === "CancelledError";
+}
 async function runCommand(runtime, commandName, options, handler, presenter) {
 	const flags = resolveGlobalFlags(runtime.argv, options);
 	const context = await createCommandContext(runtime, flags);
 	const descriptor = getCommandDescriptor(commandName);
+	const startedAt = Date.now();
 	try {
 		const success = await handler(context);
 		if (flags.json) {
@@ -23,10 +31,22 @@ async function runCommand(runtime, commandName, options, handler, presenter) {
 			});
 			return;
 		}
-		if (flags.quiet) return;
-		writeHumanLines(context.output, presenter.renderHuman(context, descriptor, success.result));
+		const stdout = presenter.renderStdout?.(context, descriptor, success.result) ?? [];
+		if (flags.quiet) {
+			if (stdout.length > 0) context.output.stdout.write(`${stdout.join("\n")}\n`);
+			return;
+		}
+		const rendered = presenter.renderHuman(context, descriptor, success.result);
+		const diagnostics = await renderBestEffortCommandDiagnostics(context, {
+			enabled: flags.verbose && rendered.length > 0,
+			durationMs: Date.now() - startedAt
+		});
+		const humanLines = [...rendered, ...diagnostics];
+		if (stdout.length > 0 && humanLines.length > 0) humanLines.push("");
+		writeHumanLines(context.output, humanLines);
+		if (stdout.length > 0) context.output.stdout.write(`${stdout.join("\n")}\n`);
 	} catch (error) {
-		const cliError = toCliError(error);
+		const cliError = toCliError(error, runtime);
 		if (cliError) {
 			if (flags.json) writeJsonError(context.output, commandName, cliError);
 			else writeHumanError(context.output, context.ui, cliError, { trace: flags.trace });
@@ -36,6 +56,14 @@ async function runCommand(runtime, commandName, options, handler, presenter) {
 		throw error;
 	}
 }
+async function renderBestEffortCommandDiagnostics(context, options) {
+	if (!options.enabled) return [];
+	try {
+		return renderCommandDiagnostics(context, await collectCommandDiagnostics(context, { durationMs: options.durationMs }));
+	} catch {
+		return [];
+	}
+}
 async function runStreamingCommand(runtime, commandName, options, handler) {
 	const flags = resolveGlobalFlags(runtime.argv, options);
 	const context = await createCommandContext(runtime, flags);
@@ -51,7 +79,7 @@ async function runStreamingCommand(runtime, commandName, options, handler) {
 			nextActions: []
 		});
 	} catch (error) {
-		const cliError = toCliError(error);
+		const cliError = toCliError(error, runtime);
 		if (cliError) {
 			if (flags.json) writeJsonEvent(context.output, {
 				type: "error",

package/dist/shell/diagnostics-output.js

@@ -0,0 +1,63 @@
+import { renderVerboseBlock } from "./ui.js";
+import path from "node:path";
+//#region src/shell/diagnostics-output.ts
+function renderCommandDiagnostics(context, diagnostics, rows = [], options = {}) {
+	if (!diagnostics) return [];
+	const { env } = context.runtime;
+	const git = diagnostics.git;
+	return renderVerboseBlock(context.ui, [
+		...rows,
+		...diagnostics.durationMs === void 0 ? [] : [{
+			key: "duration",
+			value: formatDuration(diagnostics.durationMs)
+		}],
+		{
+			key: "cwd",
+			value: formatLocalPath(diagnostics.cwd, env)
+		},
+		{
+			key: "state file",
+			value: formatLocalPath(diagnostics.stateFilePath, env)
+		},
+		...git ? [
+			{
+				key: "git ref",
+				value: git.ref ?? "detached",
+				tone: git.ref ? "default" : "dim"
+			},
+			{
+				key: "git sha",
+				value: git.sha ?? "unknown",
+				tone: git.sha ? "default" : "dim"
+			},
+			{
+				key: "git dirty",
+				value: formatDirtyState(git.dirty),
+				tone: git.dirty ? "warning" : "dim"
+			}
+		] : [{
+			key: "git",
+			value: "not detected",
+			tone: "dim"
+		}]
+	], { title: options.title ?? "Local context" });
+}
+function formatLocalPath(value, env) {
+	const resolved = path.resolve(value);
+	const home = env.HOME ? path.resolve(env.HOME) : null;
+	if (home && (resolved === home || resolved.startsWith(`${home}${path.sep}`))) {
+		const relative = path.relative(home, resolved);
+		return relative ? `~/${relative}` : "~";
+	}
+	return resolved;
+}
+function formatDirtyState(dirty) {
+	if (dirty === null) return "unknown";
+	return dirty ? "yes" : "no";
+}
+function formatDuration(durationMs) {
+	if (durationMs < 1e3) return `${durationMs}ms`;
+	return `${(durationMs / 1e3).toFixed(1)}s`;
+}
+//#endregion
+export { renderCommandDiagnostics };

package/dist/shell/errors.js

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

package/dist/shell/output.js

@@ -23,6 +23,15 @@ function cliErrorToJson(error) {
 		docsUrl: error.docsUrl
 	};
 }
+function formatUnexpectedError(error, trace) {
+	const debug = error instanceof Error ? error.stack ?? error.message : String(error);
+	if (trace) return `${debug}\n`;
+	return [
+		`Unexpected CLI error: ${error instanceof Error && error.message ? error.message : String(error)}`,
+		"More: Re-run with --trace for deeper diagnostics",
+		""
+	].join("\n");
+}
 function writeJsonError(output, command, error) {
 	output.stdout.write(`${JSON.stringify({
 		ok: false,
@@ -70,4 +79,4 @@ function writeHumanError(output, ui, error, options) {
 	writeHumanLines(output, lines);
 }
 //#endregion
-export { cliErrorToJson, writeHumanError, writeHumanLines, writeJsonError, writeJsonEvent, writeJsonSuccess };
+export { cliErrorToJson, formatUnexpectedError, writeHumanError, writeHumanLines, writeJsonError, writeJsonEvent, writeJsonSuccess };

package/dist/shell/runtime.js

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

@@ -48,6 +48,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,
@@ -73,5 +87,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 { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+import { spawn } from "node:child_process";
+//#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/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);
-			}
 		}
 	};
 }

package/dist/use-cases/project.js

@@ -22,7 +22,8 @@ function listSortedWorkspaceProjects(projectGateway, workspaceId) {
 function toProjectSummary(project) {
 	return {
 		id: project.id,
-		name: project.name
+		name: project.name,
+		...project.url ? { url: project.url } : {}
 	};
 }
 //#endregion