@prisma/cli 3.0.0-beta.3 → 3.0.0-beta.30

package/dist/shell/diagnostics-output.js

@@ -0,0 +1,57 @@
+import { renderVerboseBlock } from "./ui.js";
+import { shortenHomePath } from "../lib/fs/home-path.js";
+//#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) {
+	return shortenHomePath(value, env);
+}
+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

@@ -44,6 +44,12 @@ function usageError(summary, why, fix, nextSteps = [], domain = "cli") {
 		nextSteps
 	});
 }
+function isUsageError(error, summary) {
+	return isErrorRecord(error) && error.code === "USAGE_ERROR" && (summary === void 0 || error.summary === summary);
+}
+function isErrorRecord(error) {
+	return typeof error === "object" && error !== null;
+}
 function authRequiredError(nextSteps = ["prisma-cli auth login"], options = {}) {
 	return new CliError({
 		code: "AUTH_REQUIRED",
@@ -56,6 +62,17 @@ function authRequiredError(nextSteps = ["prisma-cli auth login"], options = {})
 		nextSteps
 	});
 }
+function authConfigInvalidError(message) {
+	return new CliError({
+		code: "AUTH_CONFIG_INVALID",
+		domain: "auth",
+		summary: "Authentication configuration is invalid",
+		why: message,
+		fix: "Provide a valid PRISMA_SERVICE_TOKEN value, or unset the variable to use local OAuth login.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli auth login"]
+	});
+}
 function commandCanceledError() {
 	return new CliError({
 		code: "COMMAND_CANCELED",
@@ -70,6 +87,44 @@ function commandCanceledError() {
 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");
 }
+function workspaceSwitchUnavailableError() {
+	return new CliError({
+		code: "WORKSPACE_SWITCH_UNAVAILABLE",
+		domain: "auth",
+		summary: "Workspace switching is unavailable",
+		why: "PRISMA_SERVICE_TOKEN is set, so authenticated commands use that token instead of local OAuth workspaces.",
+		fix: "Unset PRISMA_SERVICE_TOKEN to switch between local OAuth workspaces, or use a token for the workspace you want.",
+		exitCode: 1,
+		nextSteps: ["unset PRISMA_SERVICE_TOKEN", "prisma-cli auth workspace list"]
+	});
+}
+function workspaceNotAuthenticatedError(workspaceRef) {
+	return new CliError({
+		code: "WORKSPACE_NOT_AUTHENTICATED",
+		domain: "auth",
+		summary: "Workspace is not authenticated",
+		why: `No stored OAuth session matched "${workspaceRef}".`,
+		fix: "Run prisma-cli auth login and authorize that workspace, then switch to it.",
+		meta: { workspaceRef },
+		exitCode: 1,
+		nextSteps: ["prisma-cli auth workspace list", "prisma-cli auth login"]
+	});
+}
+function workspaceAmbiguousError(workspaceRef, matches) {
+	return new CliError({
+		code: "WORKSPACE_AMBIGUOUS",
+		domain: "auth",
+		summary: "Workspace name is ambiguous",
+		why: `Multiple authenticated workspaces matched "${workspaceRef}".`,
+		fix: "Run prisma-cli auth workspace list and switch by workspace id.",
+		meta: {
+			workspaceRef,
+			matches
+		},
+		exitCode: 2,
+		nextSteps: ["prisma-cli auth workspace list"]
+	});
+}
 function featureUnavailableError(summary, why, fix, nextSteps = [], domain = "cli") {
 	return new CliError({
 		code: "FEATURE_UNAVAILABLE",
@@ -82,4 +137,4 @@ function featureUnavailableError(summary, why, fix, nextSteps = [], domain = "cl
 	});
 }
 //#endregion
-export { CliError, authRequiredError, commandCanceledError, featureUnavailableError, usageError, workspaceRequiredError };
+export { CliError, authConfigInvalidError, authRequiredError, commandCanceledError, featureUnavailableError, isUsageError, usageError, workspaceAmbiguousError, workspaceNotAuthenticatedError, workspaceRequiredError, workspaceSwitchUnavailableError };

package/dist/shell/help.js

@@ -1,5 +1,5 @@
-import { createShellUi, padDisplay, wrapText } from "./ui.js";
 import { formatDescriptorLabel, getDescriptorForCommand } from "./command-meta.js";
+import { createShellUi, padDisplay, wrapText } from "./ui.js";
 import { COMPACT_GLOBAL_OPTION_FLAGS, resolveGlobalFlags } from "./global-flags.js";
 //#region src/shell/help.ts
 function renderHelp(command, runtime) {
@@ -10,28 +10,39 @@ function renderHelp(command, runtime) {
 	const visibleCommands = command.commands.filter((candidate) => candidate.name() !== "help" && !candidate.hidden);
 	const visibleOptions = command.options.filter((candidate) => !candidate.hidden);
 	if (visibleCommands.length > 0) lines.push(...renderCommandRows(rail, ui, visibleCommands));
-	if (descriptor.longDescription) {
-		lines.push(`${rail}`);
-		const wrapped = wrapText(descriptor.longDescription, Math.max(ui.width - 3, 40));
-		for (const line of wrapped) lines.push(`${rail}  ${line}`);
-	}
-	if (visibleOptions.length > 0) {
-		if (visibleCommands.length > 0) lines.push(`${rail}`);
-		if (visibleCommands.length > 0 && visibleOptions.every((option) => COMPACT_GLOBAL_OPTION_FLAGS.includes(option.flags))) lines.push(`${rail}  Global options:`);
-		lines.push(...renderOptionRows(rail, ui, visibleOptions));
-	}
-	if (descriptor.examples && descriptor.examples.length > 0) {
-		lines.push(`${rail}`);
-		lines.push(`${rail}  Examples:`);
-		for (const example of descriptor.examples) lines.push(`${rail}    $ ${example}`);
-	}
-	if (descriptor.docsPath) {
-		lines.push(`${rail}`);
-		lines.push(`${rail}  ${ui.accent(padDisplay("Read more", 16))}  ${ui.link(descriptor.docsPath)}`);
-	}
+	lines.push(...renderLongDescription(rail, ui, descriptor.longDescription));
+	lines.push(...renderVisibleOptions(rail, ui, visibleCommands, visibleOptions));
+	lines.push(...renderExamples(rail, runtime, descriptor.examples));
+	lines.push(...renderDocsPath(rail, ui, descriptor.docsPath));
 	lines.push("");
 	return `${lines.join("\n")}`;
 }
+function renderLongDescription(rail, ui, longDescription) {
+	if (!longDescription) return [];
+	return [`${rail}`, ...wrapText(longDescription, Math.max(ui.width - 3, 40)).map((line) => `${rail}  ${line}`)];
+}
+function renderVisibleOptions(rail, ui, visibleCommands, visibleOptions) {
+	if (visibleOptions.length === 0) return [];
+	const lines = visibleCommands.length > 0 ? [`${rail}`] : [];
+	if (shouldLabelGlobalOptions(visibleCommands, visibleOptions)) lines.push(`${rail}  Global options:`);
+	return [...lines, ...renderOptionRows(rail, ui, visibleOptions)];
+}
+function shouldLabelGlobalOptions(visibleCommands, visibleOptions) {
+	return visibleCommands.length > 0 && visibleOptions.every((option) => COMPACT_GLOBAL_OPTION_FLAGS.includes(option.flags));
+}
+function renderExamples(rail, runtime, examples) {
+	const resolvedExamples = typeof examples === "function" ? examples(runtime) : examples;
+	if (!resolvedExamples || resolvedExamples.length === 0) return [];
+	return [
+		`${rail}`,
+		`${rail}  Examples:`,
+		...resolvedExamples.map((example) => `${rail}    $ ${example}`)
+	];
+}
+function renderDocsPath(rail, ui, docsPath) {
+	if (!docsPath) return [];
+	return [`${rail}`, `${rail}  ${ui.accent(padDisplay("Read more", 16))}  ${ui.link(docsPath)}`];
+}
 function renderCommandRows(rail, ui, commands) {
 	return renderAlignedRows(rail, ui, commands.map((command) => {
 		const descriptor = getDescriptorForCommand(command);

package/dist/shell/output.js

@@ -1,3 +1,4 @@
+import { formatCommandArgument } from "./command-arguments.js";
 import { renderNextSteps, renderSummaryLine } from "./ui.js";
 //#region src/shell/output.ts
 function writeJsonSuccess(output, success) {
@@ -23,6 +24,76 @@ function cliErrorToJson(error) {
 		docsUrl: error.docsUrl
 	};
 }
+function formatUnexpectedError(error, trace, feedbackCommand) {
+	const feedbackLine = feedbackCommand ? `Tell us what happened: ${feedbackCommand}` : null;
+	const debug = error instanceof Error ? error.stack ?? error.message : String(error);
+	if (trace) return [
+		debug,
+		...feedbackLine ? [feedbackLine] : [],
+		""
+	].join("\n");
+	return [
+		`Unexpected CLI error: ${error instanceof Error && error.message ? error.message : String(error)}`,
+		"More: Re-run with --trace for deeper diagnostics",
+		...feedbackLine ? [feedbackLine] : [],
+		""
+	].join("\n");
+}
+/** Command groups whose second argv token names the subcommand. */
+const COMMAND_GROUPS = new Set([
+	"agent",
+	"auth",
+	"project",
+	"git",
+	"branch",
+	"build",
+	"database",
+	"app"
+]);
+/** Best-effort `command` label for a crash that predates envelope assembly. */
+function unexpectedErrorCommandLabel(argv) {
+	const [group, action] = argv.filter((arg) => !arg.startsWith("-"));
+	if (!group) return "unknown";
+	return action && COMMAND_GROUPS.has(group) ? `${group}.${action}` : group;
+}
+/**
+* Pre-filled feedback command for a crash, so the report arrives carrying the
+* failing command and the error's first line.
+*/
+function unexpectedErrorFeedbackCommand(argv, error) {
+	return `prisma-cli feedback ${formatCommandArgument(`${unexpectedErrorCommandLabel(argv).replace(".", " ")} crashed: ${(error instanceof Error && error.message ? error.message : String(error)).split("\n")[0]}`.slice(0, 200))}`;
+}
+/**
+* A crash must not break the `--json` contract: agents still get a structured
+* envelope, with a recover action pointing at the feedback command.
+*/
+function writeJsonUnexpectedError(output, argv, error) {
+	const feedbackCommand = unexpectedErrorFeedbackCommand(argv, error);
+	output.stdout.write(`${JSON.stringify({
+		ok: false,
+		command: unexpectedErrorCommandLabel(argv),
+		error: {
+			code: "UNEXPECTED_ERROR",
+			domain: "cli",
+			severity: "error",
+			summary: "Unexpected CLI error",
+			why: error instanceof Error && error.message ? error.message : String(error),
+			fix: "Re-run with --trace for deeper diagnostics, and report the crash.",
+			where: null,
+			meta: {},
+			docsUrl: null
+		},
+		warnings: [],
+		nextSteps: [feedbackCommand],
+		nextActions: [{
+			kind: "run-command",
+			journey: "recover",
+			label: "Report this crash to the Prisma team",
+			command: feedbackCommand,
+			reason: "This looks like a CLI bug; the pre-filled report carries the failing command and error."
+		}]
+	}, null, 2)}\n`);
+}
 function writeJsonError(output, command, error) {
 	output.stdout.write(`${JSON.stringify({
 		ok: false,
@@ -70,4 +141,4 @@ function writeHumanError(output, ui, error, options) {
 	writeHumanLines(output, lines);
 }
 //#endregion
-export { cliErrorToJson, writeHumanError, writeHumanLines, writeJsonError, writeJsonEvent, writeJsonSuccess };
+export { cliErrorToJson, formatUnexpectedError, unexpectedErrorFeedbackCommand, writeHumanError, writeHumanLines, writeJsonError, writeJsonEvent, writeJsonSuccess, writeJsonUnexpectedError };

package/dist/shell/prompt.js

@@ -1,6 +1,7 @@
-import { usageError } from "./errors.js";
+import { isUsageError, 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,33 +10,39 @@ 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 isPromptCancelError(error) {
+	return isUsageError(error, PROMPT_CANCELED_SUMMARY);
+}
 function disposePromptState(_input) {}
 //#endregion
-export { confirmPrompt, disposePromptState, selectPrompt, textPrompt };
+export { confirmPrompt, disposePromptState, isPromptCancelError, selectPrompt, textPrompt };

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,7 +21,7 @@ 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, runtime.signal);
 	return {
@@ -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

@@ -1,9 +1,9 @@
 import { getCliName, getCliVersion } from "../lib/version.js";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 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";
-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";

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 };