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

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

@@ -1,7 +1,9 @@
+import { SERVICE_TOKEN_ENV_VAR } from "./client.js";
 import { FileTokenStorage } from "../../adapters/token-storage.js";
 import { requireComputeAuth } from "./guard.js";
 import { login } from "./login.js";
 //#region src/lib/auth/auth-ops.ts
+const WORKSPACE_SUB_PREFIX = "workspace:";
 function decodeJwtPayload(token) {
 	try {
 		const payload = token.split(".")[1];
@@ -11,6 +13,17 @@ function decodeJwtPayload(token) {
 		return {};
 	}
 }
+function emailFromClaims(claims) {
+	const email = claims.email;
+	return typeof email === "string" && email.trim().length > 0 ? email.trim() : null;
+}
+function workspaceIdFromClaims(claims) {
+	const sub = claims.sub;
+	if (typeof sub !== "string") return null;
+	if (!sub.startsWith(WORKSPACE_SUB_PREFIX)) return null;
+	const id = sub.slice(10).trim();
+	return id.length > 0 ? id : null;
+}
 async function performLogin(env) {
 	await login({
 		tokenStorage: new FileTokenStorage(env),
@@ -18,36 +31,68 @@ async function performLogin(env) {
 	});
 }
 async function readAuthState(env) {
+	const rawServiceToken = env[SERVICE_TOKEN_ENV_VAR];
+	if (rawServiceToken !== void 0) {
+		const serviceToken = rawServiceToken.trim();
+		if (serviceToken.length === 0) throw new Error(`${SERVICE_TOKEN_ENV_VAR} is set but empty. Provide a valid token or unset the variable.`);
+		return readServiceTokenAuthState(serviceToken, env);
+	}
 	const tokens = await new FileTokenStorage(env).getTokens();
 	if (!tokens) return {
 		authenticated: false,
 		provider: null,
 		user: null,
-		workspace: null,
-		linkedProjectId: null
+		workspace: null
 	};
 	const claims = decodeJwtPayload(tokens.accessToken);
+	return buildAuthState({
+		workspaceIdFromCredential: tokens.workspaceId,
+		claims,
+		env
+	});
+}
+async function readServiceTokenAuthState(token, env) {
+	const claims = decodeJwtPayload(token);
+	const workspaceId = workspaceIdFromClaims(claims);
+	if (!workspaceId) return {
+		authenticated: false,
+		provider: null,
+		user: null,
+		workspace: null
+	};
+	return buildAuthState({
+		workspaceIdFromCredential: workspaceId,
+		claims,
+		env
+	});
+}
+async function buildAuthState({ workspaceIdFromCredential, claims, env }) {
+	let workspaceId = workspaceIdFromCredential;
+	let workspaceName = workspaceIdFromCredential;
 	const client = await requireComputeAuth(env);
-	let workspaceId = tokens.workspaceId;
-	let workspaceName = tokens.workspaceId;
 	if (client) try {
-		const { data } = await client.GET("/v1/workspaces/{id}", { params: { path: { id: tokens.workspaceId } } });
-		if (data?.data?.id) workspaceId = data.data.id;
+		const { data, response } = await client.GET("/v1/workspaces/{id}", { params: { path: { id: workspaceIdFromCredential } } });
+		if (response?.status === 401) return {
+			authenticated: false,
+			provider: null,
+			user: null,
+			workspace: null
+		};
+		if (data?.data?.id) {
+			workspaceId = data.data.id;
+			workspaceName = data.data.id;
+		}
 		if (data?.data?.name) workspaceName = data.data.name;
 	} catch {}
+	const email = emailFromClaims(claims);
 	return {
 		authenticated: true,
 		provider: null,
-		user: {
-			id: claims.sub ?? "",
-			name: claims.name ?? "",
-			email: claims.email ?? ""
-		},
+		user: email ? { email } : null,
 		workspace: {
 			id: workspaceId,
 			name: workspaceName
-		},
-		linkedProjectId: null
+		}
 	};
 }
 async function performLogout(env) {

package/dist/lib/auth/client.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import os from "node:os";
 //#region src/lib/auth/client.ts
 const CLIENT_ID = "cmm3lndn701oo0uefvxzo0ivw";
-const SERVICE_TOKEN_ENV_VAR = "PRISMA_API_TOKEN";
+const SERVICE_TOKEN_ENV_VAR = "PRISMA_SERVICE_TOKEN";
 const AUTH_FILE_ENV_VAR = "PRISMA_COMPUTE_AUTH_FILE";
 function getApiBaseUrl(env = process.env) {
 	return env.PRISMA_MANAGEMENT_API_URL?.trim() || "https://api.prisma.io";

package/dist/lib/auth/guard.js

@@ -6,7 +6,7 @@ import { createManagementApiClient, createManagementApiSdk } from "@prisma/manag
 * Resolve authentication and return a ManagementApiClient.
 *
 * Priority:
-*   1. PRISMA_API_TOKEN env var → service token (CI / headless)
+*   1. PRISMA_SERVICE_TOKEN env var → service token (CI / headless)
 *   2. Stored OAuth tokens     → SDK with auto-refresh
 *
 * Returns null if not authenticated.

package/dist/lib/auth/login.js

@@ -47,8 +47,9 @@ async function login(options = {}) {
 					reject(error);
 					return;
 				}
-				res.setHeader("Content-Type", "text/html");
-				res.end(`<html><body style="font-family:system-ui;max-width:400px;margin:80px auto;text-align:center"><h2>✓ Signed in</h2><p>You may now close this tab and return to the terminal.</p></body></html>`);
+				const workspaceName = await state.resolveWorkspaceName();
+				res.setHeader("Content-Type", "text/html; charset=utf-8");
+				res.end(renderSuccessPage(workspaceName));
 				resolve();
 			});
 		});
@@ -63,13 +64,14 @@ var LoginState = class {
 	latestState;
 	sdk;
 	openUrl;
+	tokenStorage;
 	constructor(options) {
 		this.options = options;
-		const tokenStorage = options.tokenStorage ?? new FileTokenStorage(options.env);
+		this.tokenStorage = options.tokenStorage ?? new FileTokenStorage(options.env);
 		this.sdk = createManagementApiSdk({
 			clientId: options.clientId ?? "cmm3lndn701oo0uefvxzo0ivw",
 			redirectUri: `http://${options.hostname}:${options.port}/auth/callback`,
-			tokenStorage,
+			tokenStorage: this.tokenStorage,
 			apiBaseUrl: options.apiBaseUrl ?? getApiBaseUrl(options.env),
 			authBaseUrl: options.authBaseUrl
 		});
@@ -109,9 +111,118 @@ var LoginState = class {
 			throw new AuthError$1(error instanceof Error ? error.message : "Unknown error during login");
 		}
 	}
+	async resolveWorkspaceName() {
+		try {
+			const tokens = await this.tokenStorage.getTokens();
+			if (!tokens?.workspaceId) return null;
+			const { data } = await this.sdk.client.GET("/v1/workspaces/{id}", { params: { path: { id: tokens.workspaceId } } });
+			const name = data?.data?.name;
+			return typeof name === "string" && name.trim().length > 0 ? name.trim() : null;
+		} catch {
+			return null;
+		}
+	}
 	get host() {
 		return `${this.options.hostname}:${this.options.port}`;
 	}
 };
+function renderSuccessPage(workspaceName) {
+	return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Prisma Developer Platform</title>
+  <style>
+    :root {
+      color-scheme: light dark;
+      --background: #ffffff;
+      --foreground: #1f2430;
+      --muted: #4f5665;
+      --mark-color: #050812;
+    }
+
+    @media (prefers-color-scheme: dark) {
+      :root {
+        --background: #050812;
+        --foreground: #f6f7fb;
+        --muted: #c5cad6;
+        --mark-color: #ffffff;
+      }
+    }
+
+    * {
+      box-sizing: border-box;
+    }
+
+    body {
+      min-height: 100vh;
+      margin: 0;
+      background: var(--background);
+      color: var(--foreground);
+      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      display: grid;
+      grid-template-rows: 128px 1fr;
+    }
+
+    .mark {
+      align-self: end;
+      justify-self: center;
+      width: 36px;
+      height: 36px;
+      color: var(--mark-color);
+    }
+
+    .mark path {
+      fill: currentColor !important;
+    }
+
+    main {
+      align-self: center;
+      justify-self: center;
+      width: min(520px, calc(100vw - 48px));
+      margin-top: -128px;
+      text-align: center;
+    }
+
+    h1 {
+      margin: 0 0 12px;
+      font-size: 26px;
+      line-height: 1.2;
+      font-weight: 700;
+      letter-spacing: 0;
+    }
+
+    p {
+      margin: 0 auto;
+      max-width: 480px;
+      color: var(--muted);
+      font-size: 15px;
+      line-height: 1.55;
+      letter-spacing: 0;
+    }
+  </style>
+</head>
+<body>
+  <svg class="mark" width="36" height="36" viewBox="0 0 32 32" xmlns="http://www.w3.org/2000/svg"><path d="M25.21,24.21,12.739,27.928a.525.525,0,0,1-.667-.606L16.528,5.811a.43.43,0,0,1,.809-.094l8.249,17.661A.6.6,0,0,1,25.21,24.21Zm2.139-.878L17.8,2.883h0A1.531,1.531,0,0,0,16.491,2a1.513,1.513,0,0,0-1.4.729L4.736,19.648a1.592,1.592,0,0,0,.018,1.7l5.064,7.909a1.628,1.628,0,0,0,1.83.678l14.7-4.383a1.6,1.6,0,0,0,1-2.218Z" style="fill:#0c344b;fill-rule:evenodd"/></svg>
+  <main>
+    <h1>You're all set.</h1>
+    <p>${workspaceName ? `Your terminal is now connected to your ${escapeHtml(workspaceName)} workspace. Head back to your terminal to continue.` : "Your terminal is now connected to your Prisma workspace. Head back to your terminal to continue."}</p>
+  </main>
+</body>
+</html>`;
+}
+function escapeHtml(value) {
+	return value.replace(/[&<>"']/g, (char) => {
+		switch (char) {
+			case "&": return "&amp;";
+			case "<": return "&lt;";
+			case ">": return "&gt;";
+			case "\"": return "&quot;";
+			case "'": return "&#39;";
+			default: return char;
+		}
+	});
+}
 //#endregion
 export { login };

package/dist/lib/project/local-pin.js

@@ -0,0 +1,51 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+//#region src/lib/project/local-pin.ts
+const LOCAL_RESOLUTION_PIN_RELATIVE_PATH = ".prisma/local.json";
+async function readLocalResolutionPin(cwd) {
+	try {
+		const raw = await readFile(path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH), "utf8");
+		const parsed = JSON.parse(raw);
+		if (!isLocalResolutionPin(parsed)) return { kind: "invalid" };
+		return {
+			kind: "present",
+			pin: parsed
+		};
+	} catch (error) {
+		if (error.code === "ENOENT") return { kind: "missing" };
+		if (error instanceof SyntaxError) return { kind: "invalid" };
+		throw error;
+	}
+}
+async function writeLocalResolutionPin(cwd, pin) {
+	const prismaDir = path.join(cwd, ".prisma");
+	await mkdir(prismaDir, { recursive: true });
+	const pinPath = path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH);
+	const tmpPath = path.join(prismaDir, `local.${process.pid}.${Date.now()}.tmp`);
+	await writeFile(tmpPath, `${JSON.stringify(pin, null, 2)}\n`, "utf8");
+	await rename(tmpPath, pinPath);
+}
+async function ensureLocalResolutionPinGitignore(cwd) {
+	const gitignorePath = path.join(cwd, ".gitignore");
+	let existing = null;
+	try {
+		existing = await readFile(gitignorePath, "utf8");
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	if (existing === null) {
+		await writeFile(gitignorePath, ".prisma/\n", "utf8");
+		return;
+	}
+	if (existing.split(/\r?\n/).map((line) => line.trim()).some((line) => line === ".prisma/" || line === ".prisma/local.json")) return;
+	await writeFile(gitignorePath, existing.endsWith("\n") ? `${existing}.prisma/\n` : `${existing}\n.prisma/\n`, "utf8");
+}
+function isLocalResolutionPin(value) {
+	if (!value || typeof value !== "object") return false;
+	const keys = Object.keys(value);
+	if (keys.length !== 2 || !keys.includes("workspaceId") || !keys.includes("projectId")) return false;
+	const candidate = value;
+	return typeof candidate.workspaceId === "string" && candidate.workspaceId.trim().length > 0 && typeof candidate.projectId === "string" && candidate.projectId.trim().length > 0;
+}
+//#endregion
+export { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, ensureLocalResolutionPinGitignore, readLocalResolutionPin, writeLocalResolutionPin };

package/dist/lib/project/resolution.js

@@ -0,0 +1,201 @@
+import { CliError } from "../../shell/errors.js";
+import { canPrompt } from "../../shell/runtime.js";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+//#region src/lib/project/resolution.ts
+async function resolveProjectTarget(options) {
+	const projects = await options.listProjects();
+	const inferredName = await inferTargetName(options.context.runtime.cwd);
+	if (options.explicitProject) return rememberIfRequested(options, resolveExplicitProject(options.explicitProject, projects, options.workspace), "explicit", {
+		targetName: options.explicitProject,
+		targetNameSource: "explicit"
+	});
+	const platformMapping = await resolveDurablePlatformMapping();
+	if (platformMapping) return rememberIfRequested(options, platformMapping, "platform-mapping");
+	let staleRemembered = false;
+	if (!options.allowCreate) {
+		const rememberedResult = await resolveRememberedProject(options, projects);
+		if (rememberedResult.target) return rememberedResult.target;
+		staleRemembered = rememberedResult.stale;
+	}
+	const packageName = inferredName.source === "package-name" ? inferredName.name : null;
+	if (packageName) {
+		const matches = projects.filter((project) => projectMatchesPackageName(project, packageName));
+		if (matches.length === 1) return rememberIfRequested(options, matches[0], "package-name", {
+			targetName: packageName,
+			targetNameSource: "package-name"
+		});
+		if (matches.length > 1) return resolveAmbiguousProject(options, matches, packageName, "package-name");
+	}
+	if (options.allowCreate && options.createProject) {
+		if (inferredName.name) {
+			const existing = projects.filter((project) => projectMatchesPackageName(project, inferredName.name));
+			if (existing.length === 1) return rememberIfRequested(options, existing[0], inferredName.source, {
+				targetName: inferredName.name,
+				targetNameSource: inferredName.source
+			});
+			if (existing.length > 1) return resolveAmbiguousProject(options, existing, inferredName.name, inferredName.source);
+			return rememberIfRequested(options, await options.createProject(inferredName.name), "created", {
+				targetName: inferredName.name,
+				targetNameSource: inferredName.source
+			});
+		}
+	}
+	if (options.prompt && canPrompt(options.context) && projects.length > 0) return rememberIfRequested(options, await options.prompt.select({
+		message: "Select a project",
+		choices: sortProjects(projects).map((project) => ({
+			label: `${project.name} (${project.id})`,
+			value: project
+		}))
+	}), "prompt");
+	if (staleRemembered && projects.length > 1) throw localStateStaleError();
+	throw projectUnresolvedError();
+}
+async function resolveRememberedProject(options, projects) {
+	const remembered = await options.context.stateStore.readRememberedProject(options.workspace.id);
+	if (!remembered) return {
+		target: null,
+		stale: false
+	};
+	const matched = projects.find((project) => project.id === remembered.id);
+	if (!matched) return {
+		target: null,
+		stale: true
+	};
+	return {
+		target: await rememberIfRequested(options, matched, "remembered-local", {
+			targetName: remembered.name,
+			targetNameSource: "remembered-local"
+		}),
+		stale: false
+	};
+}
+function projectNotFoundError(projectRef, workspace) {
+	return new CliError({
+		code: "PROJECT_NOT_FOUND",
+		domain: "project",
+		summary: "Project not found",
+		why: `The project "${projectRef}" does not exist in workspace "${workspace.name}" or is not accessible.`,
+		fix: "Pass a project id or name from prisma-cli project list.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli project list"]
+	});
+}
+function projectAmbiguousError(projectRef, matches) {
+	const firstMatch = matches[0];
+	const nextSteps = ["prisma-cli project list"];
+	if (firstMatch) nextSteps.push(`prisma-cli app deploy --project ${firstMatch.id}`);
+	return new CliError({
+		code: "PROJECT_AMBIGUOUS",
+		domain: "project",
+		summary: "Project resolution is ambiguous",
+		why: projectRef ? `Multiple projects matched "${projectRef}".` : "Multiple projects matched the current directory context.",
+		fix: "Pass --project <id-or-name> to choose the project explicitly.",
+		meta: { matches: matches.map((project) => ({
+			id: project.id,
+			name: project.name
+		})) },
+		exitCode: 1,
+		nextSteps
+	});
+}
+function projectUnresolvedError() {
+	return new CliError({
+		code: "PROJECT_UNRESOLVED",
+		domain: "project",
+		summary: "No project is resolved for this directory",
+		why: "No project could be resolved from explicit input, platform mappings, remembered local context, or package metadata.",
+		fix: "Pass --project <id-or-name> on the command that needs a project, or add a package.json name that matches an accessible project.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli project list", "prisma-cli project show --project <id-or-name>"]
+	});
+}
+function localStateStaleError() {
+	return new CliError({
+		code: "LOCAL_STATE_STALE",
+		domain: "project",
+		summary: "Remembered project context is stale",
+		why: "The remembered project is no longer available in the selected workspace, and automatic resolution would be ambiguous.",
+		fix: "Pass --project <id-or-name> to choose the project explicitly.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli project list"]
+	});
+}
+async function readPackageName(cwd) {
+	try {
+		const raw = await readFile(path.join(cwd, "package.json"), "utf8");
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object") return null;
+		const packageName = "name" in parsed ? parsed.name : null;
+		return typeof packageName === "string" && packageName.trim().length > 0 ? packageName.trim() : null;
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		if (error instanceof SyntaxError) return null;
+		throw error;
+	}
+}
+async function inferTargetName(cwd) {
+	const packageName = await readPackageName(cwd);
+	if (packageName && isValidInferredTargetName(packageName)) return {
+		name: packageName,
+		source: "package-name"
+	};
+	return {
+		name: path.basename(cwd),
+		source: "directory-name"
+	};
+}
+function isValidInferredTargetName(value) {
+	return /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(value);
+}
+function sortProjects(projects) {
+	return projects.slice().sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
+}
+function resolveExplicitProject(projectRef, projects, workspace) {
+	const matches = projects.filter((project) => project.id === projectRef || project.name === projectRef);
+	if (matches.length === 1) return matches[0];
+	if (matches.length > 1) throw projectAmbiguousError(projectRef, matches);
+	throw projectNotFoundError(projectRef, workspace);
+}
+function resolveAmbiguousProject(options, matches, projectRef, targetNameSource) {
+	if (options.prompt && canPrompt(options.context)) return options.prompt.select({
+		message: "Select a project",
+		choices: sortProjects(matches).map((project) => ({
+			label: `${project.name} (${project.id})`,
+			value: project
+		}))
+	}).then((selected) => rememberIfRequested(options, selected, "prompt", {
+		targetName: projectRef,
+		targetNameSource
+	}));
+	throw projectAmbiguousError(projectRef, matches);
+}
+function projectMatchesPackageName(project, packageName) {
+	return project.id === packageName || project.name === packageName || project.slug === packageName;
+}
+async function resolveDurablePlatformMapping() {
+	return null;
+}
+async function rememberIfRequested(options, project, projectSource, resolutionDetails) {
+	if (options.remember) await options.context.stateStore.setRememberedProject({
+		id: project.id,
+		name: project.name,
+		workspaceId: options.workspace.id
+	});
+	return {
+		workspace: options.workspace,
+		project: toProjectSummary(project),
+		resolution: {
+			projectSource,
+			...resolutionDetails
+		}
+	};
+}
+function toProjectSummary(project) {
+	return {
+		id: project.id,
+		name: project.name
+	};
+}
+//#endregion
+export { inferTargetName, projectNotFoundError, resolveProjectTarget, sortProjects };

package/dist/lib/version.js

@@ -0,0 +1,55 @@
+import { CliError } from "../shell/errors.js";
+import { createRequire } from "node:module";
+import process from "node:process";
+//#region src/lib/version.ts
+const requireFromHere = createRequire(import.meta.url);
+function readPackageMetadata() {
+	try {
+		return requireFromHere("../../package.json");
+	} catch {
+		return {};
+	}
+}
+function getCliVersion() {
+	const pkg = readPackageMetadata();
+	if (!pkg.version) throw new CliError({
+		code: "VERSION_UNAVAILABLE",
+		domain: "cli",
+		summary: "CLI version metadata is missing from the installed package",
+		why: "The bundled package.json could not be read or did not contain a version field.",
+		fix: "Reinstall the CLI from the npm registry, or check your install path is intact.",
+		exitCode: 1
+	});
+	return pkg.version;
+}
+function getCliName() {
+	return "prisma-cli";
+}
+function detectInvocation(env, argv) {
+	if (env.npm_config_user_agent?.startsWith("bun")) return "bunx";
+	const normalizedExecPath = env.npm_execpath?.replace(/\\/g, "/").toLowerCase();
+	const normalizedUserAgent = env.npm_config_user_agent?.toLowerCase();
+	if (env.npm_lifecycle_event === "npx" || normalizedExecPath?.includes("/_npx/") || normalizedUserAgent?.includes("npx")) return "npx";
+	const entry = (argv[1] ?? "").replace(/\\/g, "/").toLowerCase();
+	if (entry.endsWith(".ts") || entry.includes("/tsx/")) return "dev";
+	if (entry.includes("/_npx/")) return "npx";
+	if (entry.includes("/.bun/")) return "bunx";
+	if (entry.includes("/node_modules/.bin/") || /\/prisma-cli(\.cmd|\.exe)?$/.test(entry)) return "global";
+	return "unknown";
+}
+function buildVersionResult(env, argv) {
+	return {
+		cli: {
+			name: getCliName(),
+			version: getCliVersion()
+		},
+		node: { version: process.version },
+		os: {
+			platform: process.platform,
+			arch: process.arch
+		},
+		invocation: detectInvocation(env, argv)
+	};
+}
+//#endregion
+export { buildVersionResult, getCliName, getCliVersion };

package/dist/output/patterns.js

@@ -1,15 +1,14 @@
-import { formatDescriptorLabel } from "../shell/command-meta.js";
 import { maskValue, padDisplay, renderSummaryLine } from "../shell/ui.js";
+import { formatDescriptorLabel } from "../shell/command-meta.js";
 import stringWidth from "string-width";
 //#region src/output/patterns.ts
 function renderList(input, ui) {
-	const keyWidth = Math.max(stringWidth(`${input.parentContext.key}:`), ...input.items.map((item) => stringWidth(`⚬ ${item.noun}:`)), stringWidth("Read more"));
+	const keyWidth = Math.max(stringWidth(`${input.parentContext.key}:`), ...input.items.map((item) => stringWidth(`⚬ ${item.noun}:`)), ...readMoreWidth(input.descriptor));
 	const lines = renderCardTitle(input.descriptor, input.title, ui);
 	lines.push(renderCardRow(ui, keyWidth, input.parentContext.key, input.parentContext.value));
 	if (input.items.length === 0) lines.push(renderPlainCardLine(ui, ui.dim(input.emptyMessage)));
 	else for (const item of input.items) lines.push(renderCardRow(ui, keyWidth, `⚬ ${item.noun}`, formatListItemValue(ui, item)));
-	lines.push(renderCardDivider(ui));
-	lines.push(renderReadMore(ui, keyWidth, input.descriptor));
+	pushReadMore(lines, ui, keyWidth, input.descriptor);
 	return lines;
 }
 function serializeList(input) {
@@ -24,24 +23,18 @@ function serializeList(input) {
 	};
 }
 function renderShow(input, ui) {
-	const keyWidth = Math.max(...input.fields.map((field) => stringWidth(`${field.key}:`)), stringWidth("Read more"));
+	const keyWidth = Math.max(0, ...input.fields.map((field) => stringWidth(`${field.key}:`)), ...readMoreWidth(input.descriptor));
 	const lines = renderCardTitle(input.descriptor, input.title, ui);
 	for (const field of input.fields) lines.push(renderCardRow(ui, keyWidth, field.key, formatValue(ui, field.value, field.tone, field.sensitive)));
-	lines.push(renderCardDivider(ui));
-	lines.push(renderReadMore(ui, keyWidth, input.descriptor));
+	pushReadMore(lines, ui, keyWidth, input.descriptor);
 	return lines;
 }
 function renderMutate(input, ui) {
-	const rows = [...input.context, {
-		key: "mode",
-		value: "apply",
-		tone: "dim"
-	}];
-	const keyWidth = Math.max(...rows.map((row) => stringWidth(`${row.key}:`)), stringWidth("Read more"));
+	const rows = input.context;
+	const keyWidth = Math.max(0, ...rows.map((row) => stringWidth(`${row.key}:`)), ...readMoreWidth(input.descriptor));
 	const lines = renderCardTitle(input.descriptor, input.title, ui);
 	for (const row of rows) lines.push(renderCardRow(ui, keyWidth, row.key, formatValue(ui, row.value, row.tone, row.sensitive)));
-	lines.push(renderCardDivider(ui));
-	lines.push(renderReadMore(ui, keyWidth, input.descriptor));
+	pushReadMore(lines, ui, keyWidth, input.descriptor);
 	lines.push("");
 	lines.push(`${ui.warning("◇")} ${input.operationDescription}...`);
 	lines.push(renderSummaryLine(ui, "success", `Applied ${input.operationCount} operation(s)`));
@@ -64,8 +57,13 @@ function renderPlainCardLine(ui, text) {
 function renderCardDivider(ui) {
 	return renderCardRail(ui);
 }
-function renderReadMore(ui, keyWidth, descriptor) {
-	return `${renderCardRail(ui)}  ${ui.accent(padDisplay("Read more", keyWidth))}  ${ui.link(descriptor.docsPath ?? "")}`;
+function readMoreWidth(descriptor) {
+	return descriptor.docsPath ? [stringWidth("Read more")] : [];
+}
+function pushReadMore(lines, ui, keyWidth, descriptor) {
+	if (!descriptor.docsPath) return;
+	lines.push(renderCardDivider(ui));
+	lines.push(`${renderCardRail(ui)}  ${ui.accent(padDisplay("Read more", keyWidth))}  ${ui.link(descriptor.docsPath)}`);
 }
 function renderCardRail(ui) {
 	return ui.dim("│");
@@ -76,7 +74,6 @@ function formatListItemValue(ui, item) {
 }
 function renderAnnotation(ui, status) {
 	if (status === "active") return ui.success("(active)");
-	if (status === "linked") return ui.accent("(linked)");
 	if (status === "default") return ui.dim("(default)");
 	return "";
 }