magus-cli 7.4.1 → 7.5.0

package/src/services/profile-state.ts

@@ -0,0 +1,622 @@
+/**
+ * Which profile is active — strictly — and getting the project into a state
+ * magus can act on, before any command does.
+ *
+ * {@link checkActiveProfile} answers the question without guessing:
+ *
+ *   active       the marker names a profile profiles.json defines
+ *   unknown      the marker names a profile profiles.json does NOT define —
+ *                magus must not act on profile state; the fix is
+ *                `magus profile switch <name>`
+ *   old-layout   a defined profile is named, and something of an older layout
+ *                remains (links into `.claude/_profiles/`, the directory
+ *                itself, the older marker); converted by
+ *                {@link prepareProfileState} after what Claude Code wrote
+ *                through the old links is added to the profile
+ *   unmarked     no marker. If the live config equals the rendered output of
+ *                exactly one profile, the marker is restored for it and the
+ *                state is `active`; otherwise the TUI asks once and a
+ *                non-interactive CLI stops with the instruction.
+ *   no-profiles  profiles.json defines none (or does not exist)
+ *
+ * {@link prepareProfileState} is what entry points call: the check, then —
+ * for an active profile — absorbing Claude Code's edits and regenerating from
+ * a changed profiles.json (`profile-absorb.ts`). {@link inspectProfileState}
+ * is its read-only twin, for `magus doctor` without `--fix`.
+ */
+
+import path from "node:path";
+import type { ProfileManifest } from "../types/index.js";
+import { readManifest, writeManifest } from "./manifest.js";
+import {
+	type ReconcileResult,
+	absorbOlderLayout,
+	absorbOrphanedProfile,
+	reconcileActiveProfile,
+	refuseOnProblems,
+} from "./profile-absorb.js";
+import {
+	type ActivateOptions,
+	type ActivationResult,
+	type ProfileChoice,
+	activateProfile,
+	activationNotes,
+} from "./profile-activate.js";
+import { adoptCurrentProject } from "./profile-adopt.js";
+import {
+	type ActiveMarker,
+	LIVE_FILE_KEYS,
+	MACHINE_LOCAL_SETTINGS_KEYS,
+	folderHash,
+	hasCurrentMarker,
+	hasOlderLayout,
+	jsonEqual,
+	liveHash,
+	liveKind,
+	livePath,
+	markerFor,
+	namedActiveProfile,
+	readActiveMarker,
+	readLiveJsonSafely,
+	skillsRoot,
+	unreadableLiveFiles,
+	writeActiveMarker,
+} from "./profile-live.js";
+import { renderProfile } from "./profile-render.js";
+import {
+	SkillClashError,
+	inspectManagedSkills,
+	skillFolder,
+} from "./profile-skills.js";
+import type { SettingsParseError } from "./settings-file.js";
+
+export type ActiveProfileCheck =
+	| { state: "no-profiles" }
+	| { state: "active"; profile: string; restored: boolean }
+	| { state: "old-layout"; profile: string }
+	| {
+			state: "unknown";
+			profile: string;
+			available: string[];
+			/** The profile to suggest switching to, or null to say `<name>`. */
+			suggested: string | null;
+	  }
+	| {
+			state: "unmarked";
+			available: string[];
+			liveFiles: boolean;
+			suggested: string | null;
+			/**
+			 * The one profile the live config matches exactly, when the check
+			 * was told not to restore the marker for it (`restore: false`).
+			 */
+			match: string | null;
+	  };
+
+/**
+ * The profile a "run `magus profile switch …`" hint should name: the one the
+ * manifest declares as its default, or the only one there is. Null when
+ * neither says, and the hint names `<name>` with the choices listed.
+ */
+export function suggestedProfile(manifest: ProfileManifest): string | null {
+	const ids = Object.keys(manifest.profiles);
+	if (manifest.default !== undefined && ids.includes(manifest.default)) {
+		return manifest.default;
+	}
+	return ids.length === 1 ? (ids[0] as string) : null;
+}
+
+/**
+ * The switch command to print: a real profile name when there is one to
+ * suggest, never literal angle brackets around one.
+ */
+export function switchCommand(suggested: string | null): string {
+	return suggested !== null
+		? `magus profile switch ${suggested}`
+		: "magus profile switch <name>";
+}
+
+/** The hint sentence: the command, plus the choices when it says `<name>`. */
+export function switchHint(
+	available: readonly string[],
+	suggested: string | null,
+): string {
+	const command = `\`${switchCommand(suggested)}\``;
+	return suggested !== null
+		? command
+		: `${command} (profiles: ${available.join(", ")})`;
+}
+
+function withoutMachineKeys(
+	settings: Record<string, unknown>,
+): Record<string, unknown> {
+	const out = { ...settings };
+	for (const key of MACHINE_LOCAL_SETTINGS_KEYS) delete out[key];
+	return out;
+}
+
+/** Profiles whose rendered output equals the live config exactly. */
+async function matchingProfiles(
+	manifest: ProfileManifest,
+	projectPath: string,
+): Promise<string[]> {
+	const settings = await readLiveJsonSafely("settings", projectPath);
+	if (!settings) return [];
+	const mcp = (await readLiveJsonSafely("mcp", projectPath)) ?? {
+		mcpServers: {},
+	};
+	const models = await readLiveJsonSafely("models", projectPath);
+	const matches: string[] = [];
+	for (const id of Object.keys(manifest.profiles)) {
+		const rendered = await renderProfile(manifest, id);
+		if (
+			jsonEqual(withoutMachineKeys(settings), rendered.settings) &&
+			jsonEqual(mcp, rendered.mcp) &&
+			jsonEqual(models, rendered.models)
+		) {
+			matches.push(id);
+		}
+	}
+	return matches;
+}
+
+/**
+ * Write a marker for `profile` from the live files as they stand. Its skills
+ * whose folders exist are recorded as magus-installed: the live config is
+ * exactly this profile's, so they are its own.
+ */
+async function restoreMarker(
+	manifest: ProfileManifest,
+	profile: string,
+	projectPath: string,
+): Promise<void> {
+	const entry = manifest.profiles[profile];
+	if (!entry) return;
+	const files: ActiveMarker["files"] = {};
+	for (const key of LIVE_FILE_KEYS) {
+		const hash = await liveHash(key, projectPath);
+		if (hash) files[key] = hash;
+	}
+	const skills: Record<string, string> = {};
+	for (const ref of entry.skills ?? []) {
+		const folder = skillFolder(ref);
+		const hash = await folderHash(path.join(skillsRoot(projectPath), folder));
+		if (hash) skills[folder] = hash;
+	}
+	await writeActiveMarker(
+		markerFor(profile, await renderProfile(manifest, profile), files, skills),
+		projectPath,
+	);
+}
+
+export interface CheckOptions {
+	/**
+	 * Restore a lost marker when the live config matches exactly one profile —
+	 * the check's only write. `magus doctor` without `--fix` turns it off.
+	 */
+	restore?: boolean;
+}
+
+/**
+ * The strict active-profile check. Restoring a lost marker for a unique match
+ * is its only write, and only unless `restore: false`. Throws
+ * `SettingsParseError` when profiles.json does not parse.
+ */
+export async function checkActiveProfile(
+	projectPath: string,
+	opts: CheckOptions = {},
+): Promise<ActiveProfileCheck> {
+	const manifest = await readManifest(projectPath);
+	const available = Object.keys(manifest.profiles);
+	if (available.length === 0) return { state: "no-profiles" };
+
+	const named = await namedActiveProfile(projectPath);
+	if (named) {
+		if (!available.includes(named.profile)) {
+			return {
+				state: "unknown",
+				profile: named.profile,
+				available,
+				suggested: suggestedProfile(manifest),
+			};
+		}
+		return (await hasOlderLayout(projectPath))
+			? { state: "old-layout", profile: named.profile }
+			: { state: "active", profile: named.profile, restored: false };
+	}
+
+	const matches = await matchingProfiles(manifest, projectPath);
+	if (matches.length === 1 && opts.restore !== false) {
+		const [profile] = matches as [string];
+		await restoreMarker(manifest, profile, projectPath);
+		return { state: "active", profile, restored: true };
+	}
+	let liveFiles = false;
+	for (const key of LIVE_FILE_KEYS) {
+		if ((await liveKind(key, projectPath)) !== "missing") liveFiles = true;
+	}
+	const match = matches.length === 1 ? (matches[0] as string) : null;
+	return {
+		state: "unmarked",
+		available,
+		liveFiles,
+		suggested: match ?? suggestedProfile(manifest),
+		match,
+	};
+}
+
+/** The message for a marker naming a profile profiles.json does not define. */
+export function describeUnknownProfile(
+	check: Extract<ActiveProfileCheck, { state: "unknown" }>,
+): string {
+	return `The active profile is recorded as "${check.profile}", but .claude/profiles.json defines no such profile. Run ${switchHint(check.available, check.suggested)}.`;
+}
+
+/** The message for a project with profiles and no marker to say which is live. */
+export function describeUnmarked(
+	check: Extract<ActiveProfileCheck, { state: "unmarked" }>,
+): string {
+	return `No profile is active in this project, and its live config matches no single profile. Run ${switchHint(check.available, check.suggested)}.`;
+}
+
+/**
+ * Before an older layout is converted to activate `target`: add what Claude
+ * Code wrote through its links to the profile it belongs to — the one the
+ * layout names, or `target` when profiles.json no longer defines that one.
+ *
+ * Null when there is nothing of the kind to do: a current marker exists (its
+ * live files are reconciled instead), there is no older layout, or the layout
+ * names no profile (nothing was written through a link; a real file there is
+ * a first adoption's to back up).
+ */
+export async function absorbBeforeConversion(
+	projectPath: string,
+	target: string,
+): Promise<ReconcileResult | null> {
+	if (await hasCurrentMarker(projectPath)) return null;
+	if (!(await hasOlderLayout(projectPath))) return null;
+	const named = (await namedActiveProfile(projectPath))?.profile ?? null;
+	if (named === null) return null;
+	const manifest = await readManifest(projectPath);
+	const into = manifest.profiles[named] ? named : target;
+	return absorbOlderLayout(projectPath, into, named);
+}
+
+export interface ProfileStatePrep {
+	check: ActiveProfileCheck;
+	reconcile: ReconcileResult | null;
+	/** Everything worth printing, in order. */
+	lines: string[];
+	/**
+	 * Things that stop a command which would write profile state. When
+	 * non-empty, nothing was written.
+	 */
+	problems: string[];
+	/** The files behind `problems` that could not be parsed. */
+	unreadable: SettingsParseError[];
+}
+
+/**
+ * The entry-point gate: check which profile is active, restore a lost marker,
+ * absorb/regenerate (see `profile-absorb.ts`), and convert an older layout —
+ * after adding what Claude Code wrote through its links to the profile.
+ * Idempotent and cheap when nothing changed. Writes nothing when a live file
+ * cannot be read (`problems`).
+ */
+export async function prepareProfileState(
+	projectPath: string,
+	opts: Pick<ActivateOptions, "installSkill"> = {},
+): Promise<ProfileStatePrep> {
+	const check = await checkActiveProfile(projectPath);
+	const out: ProfileStatePrep = {
+		check,
+		reconcile: null,
+		lines: [],
+		problems: [],
+		unreadable: [],
+	};
+	const take = (r: ReconcileResult) => {
+		out.lines.push(...r.lines.filter((l) => !r.problems.includes(l)));
+		out.problems.push(...r.problems);
+		out.unreadable.push(...r.unreadable);
+	};
+
+	if (check.state === "active" && check.restored) {
+		out.lines.push(
+			`No active-profile marker, but the live config matches profile "${check.profile}" exactly — restored it`,
+		);
+	}
+
+	if (check.state === "active" || check.state === "old-layout") {
+		const profile = check.profile;
+		if (await hasCurrentMarker(projectPath)) {
+			out.reconcile = await reconcileActiveProfile(projectPath, opts);
+			take(out.reconcile);
+			if (out.problems.length > 0) return out;
+		}
+		if (await hasOlderLayout(projectPath)) {
+			const absorbed = await absorbBeforeConversion(projectPath, profile);
+			if (absorbed) {
+				take(absorbed);
+				if (out.problems.length > 0) return out;
+			}
+			const result = await activateProfile(
+				await readManifest(projectPath),
+				profile,
+				projectPath,
+				{ installSkill: opts.installSkill },
+			);
+			if (check.state === "old-layout") {
+				out.lines.push(
+					`Converted profile "${profile}" from the older layout to real files`,
+				);
+			}
+			out.lines.push(...activationNotes(result));
+		}
+		out.check = { state: "active", profile, restored: false };
+	}
+	return out;
+}
+
+export interface ProfileStateReport {
+	/** The strict check, made without restoring anything. */
+	check: ActiveProfileCheck;
+	/** What the next magus command (or `magus doctor --fix`) would do. */
+	pending: string[];
+	/** Live files that do not parse; magus writes none of them. */
+	unreadable: SettingsParseError[];
+}
+
+/**
+ * What {@link prepareProfileState} would do, without doing any of it — for
+ * `magus doctor` without `--fix`, which must not convert or write anything.
+ */
+export async function inspectProfileState(
+	projectPath: string,
+): Promise<ProfileStateReport> {
+	const check = await checkActiveProfile(projectPath, { restore: false });
+	const pending: string[] = [];
+	const unreadable = await unreadableLiveFiles(projectPath);
+	const rel = (p: string) => path.relative(projectPath, p);
+
+	if (check.state === "old-layout") {
+		pending.push(
+			`Profile "${check.profile}" is on an older magus layout (links into .claude/_profiles/). The next magus command, or \`magus doctor --fix\`, adds any changes Claude Code made under it to profiles.json, converts it to real files, and keeps .claude/_profiles/ in .claude/.magus-backups/.`,
+		);
+	} else if (check.state === "unmarked" && check.match !== null) {
+		pending.push(
+			`No active-profile marker, but the live config matches profile "${check.match}" exactly — the next magus command, or \`magus doctor --fix\`, restores it.`,
+		);
+	} else if (
+		check.state === "active" &&
+		(await hasCurrentMarker(projectPath))
+	) {
+		const marker = await readActiveMarker(projectPath);
+		if (marker) {
+			const p = check.profile;
+			for (const key of LIVE_FILE_KEYS) {
+				const kind = await liveKind(key, projectPath);
+				const file = rel(livePath(key, projectPath));
+				if (kind === "file") {
+					if ((await liveHash(key, projectPath)) !== marker.files[key]) {
+						pending.push(
+							`${file} has changes not yet recorded in profile "${p}" — the next magus command records them.`,
+						);
+					}
+				} else if (kind === "missing" && marker.files[key] !== undefined) {
+					pending.push(
+						`${file} is missing — the next magus command writes it again from profile "${p}".`,
+					);
+				}
+			}
+			if (marker.cliBookkeeping) {
+				pending.push(
+					"An interrupted magus install left the Claude CLI's plugin records in .claude/settings.json — the next magus command replaces them.",
+				);
+			}
+			const manifest = await readManifest(projectPath);
+			if ((await renderProfile(manifest, p)).definition !== marker.definition) {
+				pending.push(
+					"profiles.json changed since the live config was generated — the next magus command regenerates it.",
+				);
+			}
+			const { edited } = await inspectManagedSkills(marker.skills, projectPath);
+			for (const folder of edited) {
+				pending.push(
+					`Skill .claude/skills/${folder} was edited — the next magus command makes it a custom skill.`,
+				);
+			}
+		}
+	}
+	return { check, pending, unreadable };
+}
+
+export interface SwitchResult {
+	/** What was recorded on the way: absorbed edits, an orphaned marker's changes. */
+	lines: string[];
+	/** Why nothing was activated. Empty when the switch happened. */
+	problems: string[];
+	/** The files behind `problems` that could not be parsed. */
+	unreadable: SettingsParseError[];
+	/** The activation, when there was one. */
+	activation: ActivationResult | null;
+}
+
+/**
+ * Make `name` the active profile — the ONE switch path, for `magus profile
+ * switch`, `magus install` and the TUI's Profiles tab alike.
+ *
+ *   1. On an older layout, what Claude Code wrote through its links is added
+ *      to the profile it belongs to (`absorbBeforeConversion`).
+ *   2. Whatever Claude Code wrote into the live config belongs to the profile
+ *      being LEFT, so it is absorbed there (`reconcileActiveProfile`).
+ *   3. If that profile no longer exists in profiles.json, its unsaved changes
+ *      have nowhere to go but `name` (`absorbOrphanedProfile`).
+ *   4. `name` is activated: its live files rendered, its skills installed.
+ *
+ * Stops — having written nothing — when `name` is not defined or a live file
+ * cannot be read, and before activating when one of `name`'s skills would
+ * land on a custom skill folder.
+ */
+export async function switchToProfile(
+	projectPath: string,
+	name: string,
+	opts: ActivateOptions = {},
+): Promise<SwitchResult> {
+	const result: SwitchResult = {
+		lines: [],
+		problems: [],
+		unreadable: [],
+		activation: null,
+	};
+	const take = (r: ReconcileResult | null): boolean => {
+		if (!r) return true;
+		result.lines.push(...r.lines.filter((l) => !r.problems.includes(l)));
+		result.problems.push(...r.problems);
+		result.unreadable.push(...r.unreadable);
+		return r.problems.length === 0;
+	};
+
+	const before = await readManifest(projectPath);
+	if (!before.profiles[name]) {
+		result.problems.push(
+			`Profile "${name}" not found. Available: ${Object.keys(before.profiles).join(", ")}`,
+		);
+		return result;
+	}
+
+	if (!take(await absorbBeforeConversion(projectPath, name))) return result;
+	const installSkill = { installSkill: opts.installSkill };
+	if (!take(await reconcileActiveProfile(projectPath, installSkill))) {
+		return result;
+	}
+	if (!take(await absorbOrphanedProfile(projectPath, name))) return result;
+
+	try {
+		result.activation = await activateProfile(
+			await readManifest(projectPath),
+			name,
+			projectPath,
+			opts,
+		);
+	} catch (error) {
+		if (!(error instanceof SkillClashError)) throw error;
+		result.problems.push(error.message);
+	}
+	return result;
+}
+
+/**
+ * Carry out the user's choice from the "which profile?" question, whichever
+ * surface asked.
+ *
+ * Activating first adds anything unsaved to a profile — what Claude Code wrote
+ * under an older layout, or under a recorded profile profiles.json no longer
+ * defines — so the activation renders over nothing unrecorded; those lines are
+ * returned in `absorbed`. Throws, having written nothing, when a live file
+ * cannot be read.
+ *
+ * Adopting is two writes that must not come apart — write the manifest, then
+ * activate it.
+ */
+export async function applyProfileChoice(
+	choice: ProfileChoice,
+	manifest: ProfileManifest,
+	projectPath: string,
+	opts: ActivateOptions = {},
+): Promise<ActivationResult> {
+	if (choice.kind === "activate") {
+		const absorbed: string[] = [];
+		let changed = false;
+		for (const step of [
+			await absorbBeforeConversion(projectPath, choice.id),
+			await absorbOrphanedProfile(projectPath, choice.id),
+		]) {
+			if (!step) continue;
+			refuseOnProblems(step);
+			absorbed.push(...step.lines);
+			if (step.changes.length > 0) changed = true;
+		}
+		const result = await activateProfile(
+			changed ? await readManifest(projectPath) : manifest,
+			choice.id,
+			projectPath,
+			opts,
+		);
+		return absorbed.length > 0 ? { ...result, absorbed } : result;
+	}
+	const result = await adoptCurrentProject(
+		projectPath,
+		undefined,
+		manifest,
+		choice.id,
+	);
+	await writeManifest(result.manifest, projectPath);
+	return activateProfile(result.manifest, choice.id, projectPath, opts);
+}
+
+/**
+ * The gate, for a service about to write profile state (`models use`/`off`,
+ * a style set or cleared — from the CLI or the TUI): absorb and regenerate
+ * first, and throw — having written nothing — when that could not be done
+ * safely. The first unreadable file's `SettingsParseError` is thrown as is,
+ * so every surface reports it the way it reports any damaged settings file.
+ */
+export async function prepareProfileWrite(
+	projectPath: string,
+): Promise<ProfileStatePrep> {
+	const prep = await prepareProfileState(projectPath);
+	refuseOnProblems(prep);
+	return prep;
+}
+
+export interface CliBookkeepingOptions {
+	/**
+	 * Runs after `work`, before the reconcile — for `magus update`, which must
+	 * record the skill folders it re-fetched before they are judged edited.
+	 */
+	beforeReconcile?: () => Promise<unknown>;
+	/** Receives each line the reconcile prints (absorbed edits, problems). */
+	report?: (line: string) => void;
+}
+
+/**
+ * Run the Claude CLI's plugin installs while a profile is active, so their
+ * writes to the live settings.json are never taken for the user's edits — and
+ * the user's own edits in the same window are never lost to them.
+ *
+ * `claude plugin install --scope project` enables each plugin it installs in
+ * `.claude/settings.json`, for every profile's plugins when `magus install`
+ * runs without an argument. Before `work` starts the marker is flagged
+ * (`cliBookkeeping`). In `finally`, while the flag is still set, the live
+ * config is reconciled: anything Claude Code (or the user) wrote meanwhile —
+ * an "always allow" rule, a plugin of their own — is absorbed into the
+ * profile, and only the install's own records (a `true` for a plugin some
+ * profile names that the active one does not enable) are discarded. The
+ * reconcile renders the file and writes a fresh marker, which clears the flag.
+ *
+ * A run killed outright (Ctrl-C, a crash) leaves the flag set; the next
+ * command's reconcile does the same then, and says the run was interrupted.
+ * If the reconcile cannot read a live file, nothing is written and the flag
+ * stays for the next command. Without an active profile `work` just runs.
+ */
+export async function withCliBookkeeping<T>(
+	projectPath: string,
+	work: () => Promise<T>,
+	opts: CliBookkeepingOptions = {},
+): Promise<T> {
+	const marker = (await hasCurrentMarker(projectPath))
+		? await readActiveMarker(projectPath)
+		: null;
+	if (!marker) return work();
+	await writeActiveMarker({ ...marker, cliBookkeeping: true }, projectPath);
+	try {
+		return await work();
+	} finally {
+		await opts.beforeReconcile?.();
+		const reconciled = await reconcileActiveProfile(projectPath, {
+			cliRunFinished: true,
+		});
+		for (const line of reconciled.lines) opts.report?.(line);
+	}
+}

package/src/services/profiles.ts

@@ -3,7 +3,7 @@ import path from "node:path";
 import fs from "fs-extra";
 import type { ProfileEntry, ProfileManifest } from "../types/index.js";
 import { readProfilesFile } from "./manifest.js";
-import { activeProfile } from "./symlink-manager.js";
+import { activeProfile } from "./profile-live.js";
 
 const PROFILES_FILE = "profiles.json";
 
@@ -150,38 +150,26 @@ export function toEnabledPlugins(
 }
 
 /**
- * Apply a profile: replaces enabledPlugins in the target settings scope.
- * targetScope is where the settings will be written, independent of where
- * the profile is stored.
+ * Apply a USER-scope profile — a template in `~/.claude/profiles.json` — to
+ * `~/.claude/settings.json`, replacing its enabledPlugins.
+ *
+ * User scope only, by construction. A project's live `.claude/settings.json`
+ * is rendered from its active profile in `.claude/profiles.json`; writing
+ * enabledPlugins into it directly is what made a TUI "apply" invisible to the
+ * profile and undone by the next render. A PROJECT profile is applied by
+ * switching to it (`switchToProfile` in `profile-state.ts`), the same path as
+ * `magus profile switch`.
  */
-export async function applyProfile(
-	profileId: string,
-	profileScope: "user" | "project",
-	targetScope: "user" | "project" | "local",
-	projectPath?: string,
-): Promise<void> {
-	const data = await readProfiles(profileScope, projectPath);
-	const profile = data.profiles[profileId];
-	if (!profile) throw new Error(`Profile "${profileId}" not found`);
-
-	// Import settings functions dynamically to avoid circular deps
-	const {
-		readSettings,
-		writeSettings,
-		readGlobalSettings,
-		writeGlobalSettings,
-	} = await import("./claude-settings.js");
-
-	if (targetScope === "user") {
-		const settings = await readGlobalSettings();
-		settings.enabledPlugins = toEnabledPlugins(profile.plugins);
-		await writeGlobalSettings(settings);
-	} else {
-		// project or local both write to project settings.json
-		const settings = await readSettings(projectPath);
-		settings.enabledPlugins = toEnabledPlugins(profile.plugins);
-		await writeSettings(settings, projectPath);
-	}
+export async function applyUserProfile(profile: {
+	plugins?: Record<string, string | boolean>;
+}): Promise<void> {
+	// Dynamic import: claude-settings reaches back into this module's callers.
+	const { readGlobalSettings, writeGlobalSettings } = await import(
+		"./claude-settings.js"
+	);
+	const settings = await readGlobalSettings();
+	settings.enabledPlugins = toEnabledPlugins(profile.plugins);
+	await writeGlobalSettings(settings);
 }
 
 /** Rename a profile in-place (preserves id, createdAt) */