magus-cli 7.5.3 → 7.5.4

package/src/cli/bootstrap.ts

@@ -18,6 +18,7 @@ import {
 	type ActivationResult,
 	activateProfile,
 	activationNotes,
+	activationTrackedNotices,
 	reportDisplaced,
 } from "../services/profile-activate.js";
 import {
@@ -25,11 +26,14 @@ import {
 	adoptCurrentProject,
 } from "../services/profile-adopt.js";
 import {
+	type ProfileStartupNeed,
+	UPDATE_FORMAT_VALUE,
 	buildProfileOptions,
 	defaultOptionIndex,
 	describeNeed,
 	detectProfileStartupNeed,
 	needsNothing,
+	oldFormatNeed,
 	parseProfileChoice,
 } from "../services/profile-startup.js";
 import {
@@ -41,10 +45,23 @@ import {
 } from "../services/profile-state.js";
 import { SettingsParseError } from "../services/settings-file.js";
 import type { ProfileManifest } from "../types/index.js";
-import { dim } from "./ansi.js";
-import { confirm } from "./prompt.js";
-import { selectDialog } from "./tui-prompt.js";
-import { fail as failLine, note as noteLine } from "./update-view.js";
+import { brand } from "../ui/theme.js";
+import { badge, bold, dim } from "./ansi.js";
+import { askYesNo } from "./prompt.js";
+import { selectOption } from "./select.js";
+import {
+	type ScopeName,
+	fail as failLine,
+	field,
+	info as infoLine,
+	listItem,
+	noteBlock,
+	note as noteLine,
+	ok as okLine,
+	question,
+	scopeBadge,
+	warn as warnLine,
+} from "./update-view.js";
 
 /**
  * Report a file that exists and cannot be used — it does not parse, or parses
@@ -76,6 +93,13 @@ export function reportUnparseable(error: SettingsParseError): void {
 async function writeAndActivate(
 	result: AdoptResult,
 	projectPath: string,
+	/**
+	 * Report a generated file git tracks. Only when adopting IS the command
+	 * (`profile init`): `install` and `update` report it themselves right
+	 * after — install's switch, update's own check — so adoption inside them
+	 * said it twice in one run.
+	 */
+	reportTracked: boolean,
 ): Promise<void> {
 	// Relative to the project throughout. These are all project paths, and an
 	// absolute one wraps over two terminal lines — several wrapped lines in a row
@@ -84,7 +108,12 @@ async function writeAndActivate(
 	const rel = (p: string) => path.relative(projectPath, p);
 
 	await writeManifest(result.manifest, projectPath);
-	console.log(`✓ Wrote ${rel(getManifestPath(projectPath))}`);
+	console.log(okLine(`Saved profile ${bold(result.profileId)}`));
+	console.log(
+		noteLine(
+			`Commit ${rel(getManifestPath(projectPath))} so your team gets the same plugins.`,
+		),
+	);
 
 	// Each move is printed as it happens, not from the returned list afterwards.
 	// Activation writes three files in sequence, so a throw on the third would
@@ -96,14 +125,28 @@ async function writeAndActivate(
 		projectPath,
 		{ onDisplace: reportDisplaced(projectPath) },
 	);
-	console.log(`✓ Active profile: ${result.profileId}`);
-	printActivationNotes(activation);
+	console.log(okLine(`Using profile ${bold(result.profileId)}`));
+	printActivationNotes(activation, { tracked: reportTracked });
 	console.log();
 }
 
-/** Print what activation did beyond the switch itself, one line each. */
-export function printActivationNotes(result: ActivationResult): void {
-	for (const line of activationNotes(result)) console.log(noteLine(line));
+/**
+ * Print what activation did beyond the switch itself: notes one line each, and
+ * — unless `tracked` is false — a tracked generated file as a warning with its
+ * fix beneath.
+ */
+export function printActivationNotes(
+	result: ActivationResult,
+	opts: { tracked?: boolean } = {},
+): void {
+	for (const line of activationNotes(result, { tracked: false })) {
+		console.log(noteLine(line));
+	}
+	if (opts.tracked === false) return;
+	for (const n of activationTrackedNotices(result)) {
+		console.log(warnLine(n.problem));
+		for (const line of n.fix) console.log(noteLine(line));
+	}
 }
 
 export interface ProfileGateOptions {
@@ -113,6 +156,39 @@ export interface ProfileGateOptions {
 	 * exists — `profile switch`, `install`.
 	 */
 	allowUnknown?: boolean;
+	/** `--yes`: update an old profile format without asking. */
+	yes?: boolean;
+}
+
+/**
+ * An old magus profile format: the shared `old-format` state, stated with the
+ * TUI's own title and message and — with a person at the terminal and no
+ * `--yes` — asked with the TUI's own rows. Returns false when the user
+ * declines; the command then stops, since magus cannot manage a project in a
+ * format it no longer writes. With nobody to ask it updates, as before: CI and
+ * `--yes` must not hang on a question.
+ */
+async function confirmFormatUpdate(
+	projectPath: string,
+	opts: ProfileGateOptions,
+): Promise<boolean> {
+	const need = await oldFormatNeed(projectPath);
+	if (need === null || need.state !== "old-format") return true;
+	const { title, message } = describeNeed(need);
+	console.log("");
+	console.log(warnLine(bold(title)));
+	for (const line of noteBlock(message, process.stdout.columns)) {
+		console.log(line);
+	}
+	console.log("");
+	if (opts.yes || !process.stdin.isTTY || !process.stdout.isTTY) return true;
+	const options = buildProfileOptions(need);
+	const picked = await selectOption("Update the profile format?", options, 0);
+	if (picked !== null && options[picked]?.value === UPDATE_FORMAT_VALUE) {
+		return true;
+	}
+	console.log(infoLine("Nothing changed."));
+	return false;
 }
 
 /**
@@ -129,6 +205,7 @@ export async function profileGate(
 	projectPath: string,
 	opts: ProfileGateOptions = {},
 ): Promise<boolean> {
+	if (!(await confirmFormatUpdate(projectPath, opts))) return false;
 	let prep: Awaited<ReturnType<typeof prepareProfileState>>;
 	try {
 		prep = await prepareProfileState(projectPath);
@@ -154,64 +231,128 @@ export async function profileGate(
 	return true;
 }
 
-/** Print what adoption would capture, so the user can judge it before writing. */
+/** The plugin as a user reads it: its name, and its marketplace only when that is not magus's own. */
+function pluginLabel(id: string): string {
+	const at = id.lastIndexOf("@");
+	if (at <= 0) return id;
+	const market = id.slice(at + 1);
+	return market === "magus"
+		? id.slice(0, at)
+		: `${id.slice(0, at)} ${dim(market)}`;
+}
+
+/** Longest list shown before it is cut to "+ N more". */
+const LIST_MAX = 12;
+
+/** Print up to LIST_MAX entries under a field, then how many were left out. */
+function printList(entries: string[]): void {
+	for (const entry of entries.slice(0, LIST_MAX)) console.log(listItem(entry));
+	if (entries.length > LIST_MAX) {
+		console.log(listItem(dim(`+ ${entries.length - LIST_MAX} more`)));
+	}
+}
+
+/**
+ * Print the state and what adoption would capture, so the user can judge it
+ * before the question below.
+ *
+ * In the user's terms only: the state ("no profiles yet"), the plugins as a
+ * list with the SCOPE they come from, and anything that affects the team.
+ * Never where magus stores things — the owner, on the version that printed
+ * "from this folder's .claude/settings.json" and a relative path: users
+ * operate in scopes (user, project, local), not in files, and a mechanism
+ * they never chose is noise.
+ */
 function printAdoptionPlan(result: AdoptResult): void {
+	console.log("");
+	console.log(warnLine(bold("No profiles in this project yet")));
 	console.log(
-		"\nThis project has no .claude/profiles.json — magus can create one from its current setup.\n",
+		noteLine(
+			"magus keeps a project's plugins in a profile: a named set your team gets",
+		),
 	);
-	console.log(`  profile      ${result.profileId} (${result.entry.name})`);
 	console.log(
-		`  plugins      ${result.counts.plugins} enabled, adopted as "latest"`,
+		noteLine(
+			"by committing it. Save what this project uses now as the first one.",
+		),
 	);
-	if (result.source === "user") {
-		// Never let this be invisible: the generated file is meant to be committed,
-		// and these came from ~/.claude/settings.json — this machine's personal
-		// global set, not anything this repo chose.
-		console.log(
-			"               ⚠ read from ~/.claude/settings.json (user scope) — this project",
-		);
-		console.log(
-			"                 enables none of its own. Review before committing.",
-		);
-	}
-	if (result.counts.mcpServers > 0) {
-		console.log(`  mcp servers  ${result.counts.mcpServers} from .mcp.json`);
+	console.log("");
+
+	console.log(
+		field(
+			"profile",
+			`${bold(result.profileId)}  ${badge("NEW", brand.success)}`,
+		),
+	);
+	const scope: ScopeName = result.source === "user" ? "user" : "project";
+	console.log(
+		field(
+			"plugins",
+			`${bold(String(result.counts.plugins))}  ${scopeBadge(scope)}`,
+		),
+	);
+	printList(Object.keys(result.entry.plugins ?? {}).map(pluginLabel));
+	const servers = Object.keys(result.entry.mcpServers ?? {});
+	if (servers.length > 0) {
+		console.log(field("mcp servers", bold(String(servers.length))));
+		printList(servers);
 	}
-	if (result.counts.settingsKeys > 0) {
+	console.log("");
+
+	const warned =
+		result.source === "user" ||
+		result.skipped.length > 0 ||
+		result.machinePaths.length > 0;
+	if (result.source === "user") {
+		// Never let this be invisible: the profile is meant to be committed, and
+		// these are one person's global set, not anything this project chose.
+		console.log(warnLine("This project has no plugins of its own"));
 		console.log(
-			`  settings     ${result.counts.settingsKeys} keys carried over`,
+			noteLine(
+				"These are your USER plugins, on in every project. Check them before committing.",
+			),
 		);
 	}
 	for (const id of result.skipped) {
 		console.log(
-			`  ⚠ skipped ${id} — no marketplace in its id, not reproducible`,
+			warnLine(`${id} can't be shared — it isn't from a marketplace`),
 		);
 	}
 	for (const hit of result.machinePaths) {
-		console.log(`  ⚠ machine path  ${hit}`);
-	}
-	if (result.machinePaths.length > 0) {
 		console.log(
-			"    Those name a directory on THIS machine and will not resolve on another.",
+			warnLine(`A setting points to a folder on this computer: ${hit}`),
 		);
 	}
-	console.log(
-		"\nCommit the file to share this setup with the team; edit it to pin versions.",
-	);
-	// Said before the question, not after it: adopting also SWITCHES the project
-	// onto the profile, which replaces two files that are in the working tree
-	// right now. The prompt below is the only place to decline.
-	console.log(
-		"The project then runs this profile: .claude/settings.json and .mcp.json are",
-	);
-	console.log(
-		"generated from it, and your current copies are kept where the run reports.",
-	);
+	if (result.machinePaths.length > 0) {
+		console.log(noteLine("Your teammates won't have it."));
+	}
+	if (warned) console.log("");
+}
+
+/**
+ * A state that stops the command, stated the way the TUI states it: the same
+ * title and message from `describeNeed`, dim — nothing is wrong, and there is
+ * nothing to choose from the CLI.
+ */
+function printNeedNote(need: ProfileStartupNeed): void {
+	const { title, message } = describeNeed(need);
+	console.log("");
+	console.log(noteLine(bold(title)));
+	for (const line of noteBlock(message, process.stdout.columns)) {
+		console.log(line);
+	}
+	console.log("");
 }
 
 export interface EnsureManifestOptions {
 	/** Read-only mode: never write, just report that adoption is needed. */
 	check?: boolean;
+	/**
+	 * Report a tracked generated file after activating. False for a caller that
+	 * already reported it this run (`update` checks before it asks), so it is
+	 * said once.
+	 */
+	reportTracked?: boolean;
 	/**
 	 * Adopt without prompting. Set only by `magus profile init`, where
 	 * creating the manifest IS the command the user asked for.
@@ -241,14 +382,30 @@ export async function ensureManifest(
 	}
 	if (Object.keys(manifest.profiles).length > 0) return manifest;
 
+	// Inside a project that has profiles: the shared startup state says so, and
+	// the command stops — the TUI shows the same state as its startup question.
+	// Only `profile init` (`allowAdopt`), run on purpose, gives a subfolder a
+	// setup of its own.
+	if (!opts.allowAdopt) {
+		const need = await detectProfileStartupNeed(projectPath);
+		if (need.state === "nested") {
+			printNeedNote(need);
+			return null;
+		}
+	}
+
 	const result = await adoptCurrentProject(projectPath);
 
 	if (result.counts.plugins === 0) {
 		console.error(
-			`No .claude/profiles.json in ${projectPath}, and no enabled plugins to adopt one from.`,
+			failLine(
+				`No profile in ${path.basename(projectPath)}, and no plugins to save as one`,
+			),
 		);
 		console.error(
-			"Open magus and select the plugins this project needs, then re-run.",
+			noteLine(
+				"Open magus, pick the plugins this folder needs, then run this again.",
+			),
 		);
 		return null;
 	}
@@ -257,8 +414,9 @@ export async function ensureManifest(
 
 	if (opts.check) {
 		console.error(
-			"\n--check is read-only and will not create the manifest. Run `magus install` once to adopt.",
+			failLine("--check is read-only, so it does not create the profile"),
 		);
+		console.error(noteLine("Run `magus install` once to create it."));
 		return null;
 	}
 
@@ -272,15 +430,20 @@ export async function ensureManifest(
 		// fall through to the write
 	} else if (!process.stdin.isTTY) {
 		console.error(
-			"\nRefusing to create .claude/profiles.json without a human: run `magus profile init` to create it deliberately.",
+			failLine("No profile in this folder, and nobody here to ask"),
+		);
+		console.error(
+			noteLine("Run `magus profile init` to create one deliberately."),
 		);
 		return null;
-	} else if (!(await confirm("\nCreate it and switch to it?"))) {
-		console.log("Aborted — nothing written.");
+	} else if (
+		!(await askYesNo(question(`Save as profile "${result.profileId}"?`)))
+	) {
+		console.log(infoLine("Nothing written."));
 		return null;
 	}
 
-	await writeAndActivate(result, projectPath);
+	await writeAndActivate(result, projectPath, opts.allowAdopt === true);
 	return result.manifest;
 }
 
@@ -331,7 +494,7 @@ export async function requireActiveProfile(
 		console.log(
 			`✓ Active profile: ${result.profileId} ${dim("(declared by this project)")}`,
 		);
-		printActivationNotes(result);
+		printActivationNotes(result, { tracked: opts.reportTracked !== false });
 		console.log("");
 		return readManifest(projectPath);
 	}
@@ -347,7 +510,9 @@ export async function requireActiveProfile(
 	}
 
 	// CI has nobody to ask. Exiting beats hanging on an answer that cannot come.
-	if (!process.stdin.isTTY) {
+	// Both ends: with stdout piped the list cannot draw, and "No profile chosen"
+	// would claim an answer nobody was asked for.
+	if (!process.stdin.isTTY || !process.stdout.isTTY) {
 		console.error(failLine(title));
 		console.error(
 			noteLine(
@@ -362,27 +527,35 @@ export async function requireActiveProfile(
 		return null;
 	}
 
+	// The choices the TUI's startup modal offers, built by the same functions,
+	// as an arrow-key list in the report style — the CLI mounts no TUI.
+	const options = buildProfileOptions(need);
+	const def = defaultOptionIndex(need);
 	console.log("");
-	const chosen = await selectDialog({
-		title,
-		message: describeNeed(need).message,
-		options: buildProfileOptions(need),
-		defaultIndex: defaultOptionIndex(need),
-	});
+	console.log(warnLine(bold(title)));
+	for (const line of noteBlock(
+		describeNeed(need).message,
+		process.stdout.columns,
+	)) {
+		console.log(line);
+	}
+	console.log("");
+	const picked = await selectOption("Choose a profile", options, def);
 
-	// Esc, Ctrl+C and the "Quit magus" row all land here, and there is no third
+	// "Quit magus", Esc and Ctrl+C all land here, and there is no third
 	// outcome: the command stops rather than proceed without a profile.
-	const choice = chosen === null ? null : parseProfileChoice(chosen, need);
+	const value = picked === null ? undefined : options[picked]?.value;
+	const choice = value === undefined ? null : parseProfileChoice(value, need);
 	if (!choice) {
-		console.error(failLine("No active profile — stopping."));
+		console.error(failLine("No profile chosen — stopping."));
 		return null;
 	}
 
 	const result = await applyProfileChoice(choice, need.manifest, projectPath, {
 		onDisplace: reportDisplaced(projectPath),
 	});
-	console.log(`✓ Active profile: ${result.profileId}`);
-	printActivationNotes(result);
+	console.log(okLine(`Using profile ${bold(result.profileId)}`));
+	printActivationNotes(result, { tracked: opts.reportTracked !== false });
 	console.log("");
 
 	// Re-read rather than return `need.manifest`: adopting wrote a new profile

package/src/cli/doctor.ts

@@ -46,7 +46,7 @@ import {
 	type RepoRootCache,
 	pickLoadedEntry,
 } from "../services/plugin-resolution.js";
-import { trackedGeneratedWarnings } from "../services/profile-activate.js";
+import { trackedGeneratedNotices } from "../services/profile-activate.js";
 import {
 	LIVE_FILE_KEYS,
 	liveKind,
@@ -555,8 +555,9 @@ export async function reportProfileState(
 	// A .gitignore entry does not untrack a file committed before it. A note
 	// with the fix, not a failure: magus writes the file all the same, and
 	// never runs git rm itself.
-	for (const line of await trackedGeneratedWarnings(projectPath)) {
-		console.log(`• ${line}`);
+	for (const n of await trackedGeneratedNotices(projectPath)) {
+		console.log(`• ${n.problem}`);
+		for (const line of n.fix) console.log(`  ${line}`);
 	}
 	return { fixable, unfixable };
 }

package/src/cli/install.ts

@@ -48,9 +48,20 @@ import { bringLoadForward } from "../services/update-engine.js";
 import type { ResolvedBin, ResolvedClosure } from "../types/index.js";
 import { formatCommand, resolveExecutable } from "../utils/command-utils.js";
 import { runCommand, runShellScript } from "../utils/run.js";
+import { bold } from "./ansi.js";
 import { ensureManifest, printActivationNotes } from "./bootstrap.js";
-import { confirm, promptValue } from "./prompt.js";
-import { note as noteLine } from "./update-view.js";
+import { askYesNo, promptValue } from "./prompt.js";
+import { selectOption } from "./select.js";
+import {
+	commandHeader,
+	fail as failLine,
+	field,
+	info as infoLine,
+	note as noteLine,
+	ok as okLine,
+	question,
+	warn as warnLine,
+} from "./update-view.js";
 
 interface InstallFlags {
 	check: boolean;
@@ -119,8 +130,10 @@ async function ensureToolchains(
 		}
 		const ok =
 			yes ||
-			(await confirm(
-				`${tc.name} is missing (needed by ${tc.requiredBy.join(", ")}). Install it?`,
+			(await askYesNo(
+				question(
+					`${tc.name} is missing — ${tc.requiredBy.join(", ")} need${tc.requiredBy.length === 1 ? "s" : ""} it. Install it?`,
+				),
 			));
 		if (ok) {
 			console.log(`Installing ${tc.name}…`);
@@ -149,15 +162,18 @@ async function ensureToolchains(
  * EVERY profile's plugins — so the caller runs this inside
  * `withCliBookkeeping`, which renders the live files over it afterwards.
  */
-async function installPlugins(closure: ResolvedClosure): Promise<void> {
+async function installPlugins(closure: ResolvedClosure): Promise<string[]> {
+	const installed: string[] = [];
 	for (const pluginId of Object.keys(closure.plugins)) {
 		try {
 			console.log(`+ plugin ${pluginId}`);
 			await installPlugin(pluginId, "project");
+			installed.push(pluginId);
 		} catch (e) {
 			console.warn(`⚠ plugin ${pluginId}: ${(e as Error).message}`);
 		}
 	}
+	return installed;
 }
 
 /**
@@ -176,7 +192,15 @@ async function bringLoadsForward(
 			"project",
 			projectPath,
 		);
-		if (!here) continue;
+		if (!here) {
+			// Skipped rather than checked against another scope's record: that
+			// would repair toward a version this project does not have. Said, so a
+			// plugin that installed but left nothing to check is not silent.
+			console.warn(
+				`⚠ ${pluginId}: installed, but Claude Code recorded no version for this project, so magus cannot check which version loads here`,
+			);
+			continue;
+		}
 		const forward = await bringLoadForward(pluginId, here, projectPath);
 		if (!forward) continue;
 		if (forward.ok) {
@@ -314,18 +338,32 @@ export async function runInstallCommand(
 	}
 
 	// Plan
-	console.log(`\nPlan for ${flags.profile ?? "all profiles"}:`);
-	for (const line of summarizeClosure(closure)) console.log(`  ${line}`);
+	// In the report style `update` uses: a header, then the plan as aligned
+	// rows. `summarizeClosure` pads each line as "label  values"; split at the
+	// padding so the label takes the dim label column.
+	for (const line of commandHeader(
+		"install",
+		flags.profile
+			? { label: "profile", value: flags.profile }
+			: { label: "profiles", value: "all" },
+	)) {
+		console.log(line);
+	}
+	for (const line of summarizeClosure(closure)) {
+		const [label, ...rest] = line.split(/ {2,}/);
+		console.log(field(label ?? "", rest.join("  ")));
+	}
+	console.log("");
 	if (closure.conflicts?.length) {
 		console.log(
-			"\n⚠ Version conflicts across profiles (resolved to the higher pin):",
+			warnLine("Profiles pin different versions — the higher pin wins"),
 		);
-		for (const c of closure.conflicts) console.log(`  ${c}`);
+		for (const c of closure.conflicts) console.log(noteLine(c));
+		console.log("");
 	}
-	console.log();
 
-	if (!flags.yes && !(await confirm("Apply?"))) {
-		console.log("Aborted.");
+	if (!flags.yes && !(await askYesNo(question("Install this plan?")))) {
+		console.log(infoLine("Nothing installed."));
 		return 0;
 	}
 
@@ -363,6 +401,10 @@ export async function runInstallCommand(
 		flags.profile ??
 		current ??
 		(await pickActiveProfile(profileIds, flags.yes));
+	if (activeId === null) {
+		console.error(failLine("No profile chosen — stopping."));
+		return 1;
+	}
 	if (activeId) {
 		// The one switch path: what Claude Code wrote into the live config — or
 		// through an older layout's links — goes into the profile it was written
@@ -375,10 +417,10 @@ export async function runInstallCommand(
 		});
 		for (const line of switched.lines) console.log(noteLine(line));
 		if (!switched.activation) {
-			for (const problem of switched.problems) console.error(problem);
+			for (const problem of switched.problems) console.error(failLine(problem));
 			return 1;
 		}
-		console.log(`\n✓ Active profile: ${activeId}`);
+		console.log(okLine(`Active profile ${bold(activeId)}`));
 		printActivationNotes(switched.activation);
 	}
 
@@ -387,11 +429,16 @@ export async function runInstallCommand(
 	// while they run and reconciles in `finally`: what the user changed in the
 	// meantime is kept, only the install's own records are discarded, and a
 	// Ctrl-C leaves the flag for the next command to do the same.
-	await withCliBookkeeping(projectPath, () => installPlugins(closure), {
-		installable: Object.keys(closure.plugins),
-		report: (line) => console.log(noteLine(line)),
-	});
-	await bringLoadsForward(Object.keys(closure.plugins), projectPath);
+	const installed = await withCliBookkeeping(
+		projectPath,
+		() => installPlugins(closure),
+		{
+			installable: Object.keys(closure.plugins),
+			report: (line) => console.log(noteLine(line)),
+		},
+	);
+	// Only what installed: a failed install already printed its own warning.
+	await bringLoadsForward(installed, projectPath);
 	await installBins(closure.bins);
 
 	if (activeId) {
@@ -406,16 +453,25 @@ export async function runInstallCommand(
 	return 0;
 }
 
+/**
+ * Which profile to make active when none is: the only one, the first under
+ * `--yes` or with nobody at the terminal, else the user's pick from an
+ * arrow-key list. Null when the user cancels the list — the install stops then,
+ * since magus does not run a project without a profile.
+ */
 async function pickActiveProfile(
 	profileIds: string[],
 	yes: boolean,
-): Promise<string | undefined> {
+): Promise<string | undefined | null> {
 	if (profileIds.length === 0) return undefined;
 	if (profileIds.length === 1) return profileIds[0];
-	if (yes) return profileIds[0];
-	console.log("\nWhich profile should be active?");
-	profileIds.forEach((id, i) => console.log(`  ${i + 1}) ${id}`));
-	const answer = await promptValue("Choose [1]: ");
-	const idx = answer ? Number.parseInt(answer, 10) - 1 : 0;
-	return profileIds[idx] ?? profileIds[0];
+	if (yes || !process.stdin.isTTY || !process.stdout.isTTY) {
+		return profileIds[0];
+	}
+	console.log("");
+	const picked = await selectOption(
+		"Which profile should be active?",
+		profileIds.map((id) => ({ label: id })),
+	);
+	return picked === null ? null : profileIds[picked];
 }