magus-cli 7.4.0 → 7.5.0

package/src/__tests__/models-manager.test.ts

@@ -23,6 +23,8 @@ import {
 	readModelsStatus,
 	resolveFullModelId,
 } from "../services/models-manager.js";
+import { activateProfile } from "../services/profile-activate.js";
+import { liveHash, readActiveMarker } from "../services/profile-live.js";
 import type { ProfileManifest } from "../types/index.js";
 
 let project: string;
@@ -55,22 +57,16 @@ function manifestWith(profile: string, extra = {}): ProfileManifest {
 
 /**
  * Stage a project that already has a profile ACTIVE, the way `magus install`
- * leaves one: a materialized dir and `.claude/settings.json` symlinked into it.
- * Built by hand rather than by running install, which needs the claude CLI.
+ * leaves one: the live files rendered from the manifest and recorded in the
+ * marker. Built without running install, which needs the claude CLI.
  */
 async function stageActiveProfile(
 	name: string,
 	entry: Record<string, unknown> = {},
-	settings: Record<string, unknown> = {},
 ): Promise<void> {
-	await writeManifest(manifestWith(name, entry), project);
-	const dir = join(project, ".claude", "_profiles", name);
-	await fs.outputJson(join(dir, "settings.json"), settings, { spaces: 2 });
-	await fs.ensureDir(join(project, ".claude"));
-	await fs.symlink(
-		join("_profiles", name, "settings.json"),
-		join(project, ".claude", "settings.json"),
-	);
+	const manifest = manifestWith(name, entry);
+	await writeManifest(manifest, project);
+	await activateProfile(manifest, name, project, { onDisplace: () => {} });
 }
 
 async function readSettings(): Promise<Record<string, unknown>> {
@@ -131,34 +127,55 @@ describe("applyModelPreset", () => {
 		expect(again.hook).toBe("already");
 	});
 
-	// The symlink is how the active profile is wired. `updateSettingsFile` writes
-	// through it on purpose; a remove-then-create would silently detach the
-	// project from its profile and leave the next read looking at a fresh file.
-	test("keeps the profile symlink and updates profiles.json under it", async () => {
+	// settings.json and models.json are real files rendered from the manifest
+	// (Claude Code refuses to write through a symlink), recorded in the marker.
+	test("renders settings.json and models.json from the profile as real files", async () => {
 		await stageActiveProfile("team", { plugins: { "dev@magus": "latest" } });
 
 		await applyModelPreset({ projectPath: project, preset: PRESET });
 
-		const link = join(project, ".claude", "settings.json");
-		expect((await fs.lstat(link)).isSymbolicLink()).toBe(true);
-		expect(await fs.readlink(link)).toBe(
-			join("_profiles", "team", "settings.json"),
-		);
-
-		// The write landed in the profile's copy, and re-materializing did not
-		// cost the profile the plugins its manifest entry declares.
-		const inProfile = await fs.readJson(
-			join(project, ".claude", "_profiles", "team", "settings.json"),
+		const live = join(project, ".claude", "settings.json");
+		expect((await fs.lstat(live)).isFile()).toBe(true);
+		const settings = await readSettings();
+		expect(settings.model).toBe("opus");
+		// Rendering from the manifest kept the plugins the entry declares.
+		expect(
+			(settings.enabledPlugins as Record<string, boolean>)["dev@magus"],
+		).toBe(true);
+		const marker = await readActiveMarker(project);
+		expect(marker?.files.settings).toBe(
+			(await liveHash("settings", project)) ?? "",
 		);
-		expect(inProfile.model).toBe("opus");
-		expect(inProfile.enabledPlugins["dev@magus"]).toBe(true);
-
-		// And .claude/models.json is a link into the same profile dir, not a copy.
-		const modelsLink = join(project, ".claude", "models.json");
-		expect((await fs.lstat(modelsLink)).isSymbolicLink()).toBe(true);
-		expect(await fs.readlink(modelsLink)).toBe(
-			join("_profiles", "team", "models.json"),
+		expect(marker?.files.models).toBe(
+			(await liveHash("models", project)) ?? "",
 		);
+
+		const modelsFile = join(project, ".claude", "models.json");
+		expect((await fs.lstat(modelsFile)).isSymbolicLink()).toBe(false);
+		expect((await fs.readJson(modelsFile)).preset).toBe(PRESET);
+		expect(
+			await fs.pathExists(join(project, ".claude", "profiles", "team")),
+		).toBe(false);
+	});
+
+	test("a Claude Code edit to settings.json is absorbed into the profile, then the keys are added", async () => {
+		await stageActiveProfile("team");
+		// Claude Code wrote a permission; that is a change to the active profile.
+		await fs.writeJson(join(project, ".claude", "settings.json"), {
+			enabledPlugins: {},
+			permissions: { allow: ["Bash(ls)"] },
+		});
+
+		await applyModelPreset({ projectPath: project, preset: PRESET });
+
+		const settings = await readSettings();
+		expect(settings.model).toBe("opus");
+		expect(settings.permissions).toEqual({ allow: ["Bash(ls)"] });
+		const manifest = await fs.readJson(getManifestPath(project));
+		expect(manifest.profiles.team.settings.permissions).toEqual({
+			allow: ["Bash(ls)"],
+		});
+		expect(manifest.profiles.team.settings.model).toBe("opus");
 	});
 
 	test("without a profile it writes a plain models.json and records nothing", async () => {
@@ -212,20 +229,15 @@ describe("applyModelPreset", () => {
 });
 
 describe("clearModels", () => {
-	test("removes the config, the link, and the manifest entry", async () => {
+	test("removes the config file and the manifest entry", async () => {
 		await stageActiveProfile("team");
 		await applyModelPreset({ projectPath: project, preset: PRESET });
 
 		await clearModels(project);
 
 		expect(await fs.pathExists(configPath(project))).toBe(false);
-		// lstat, not pathExists: a DANGLING symlink is the failure this guards.
 		await expect(fs.lstat(configPath(project))).rejects.toThrow();
-		expect(
-			await fs.pathExists(
-				join(project, ".claude", "_profiles", "team", "models.json"),
-			),
-		).toBe(false);
+		expect((await readActiveMarker(project))?.files.models).toBeUndefined();
 
 		const manifest = await fs.readJson(getManifestPath(project));
 		expect(manifest.profiles.team.models).toBeUndefined();