magus-cli 7.5.1 → 7.5.3

package/src/__tests__/profile-state.test.ts

@@ -13,7 +13,7 @@ import { ensureManifest, profileGate } from "../cli/bootstrap.js";
 import { reportProfileState, runDoctorCommand } from "../cli/doctor.js";
 import { runModelsCommand } from "../cli/models.js";
 import { route } from "../cli/router.js";
-import { installPlugin, uninstallPlugin } from "../services/claude-cli.js";
+import { runUpdateCommand } from "../cli/update.js";
 import {
 	readSettings,
 	writeMcpConfig,
@@ -25,6 +25,7 @@ import type { ModelsConfig } from "../services/models-core.js";
 import { reconcileActiveProfile } from "../services/profile-absorb.js";
 import {
 	activateProfile,
+	activationNotes,
 	regenerateLiveFiles,
 	trackedGeneratedFiles,
 } from "../services/profile-activate.js";
@@ -44,10 +45,6 @@ import {
 	switchToProfile,
 } from "../services/profile-state.js";
 import { applyUserProfile } from "../services/profiles.js";
-import {
-	GitCheckError,
-	TrackedLiveFileError,
-} from "../services/tracked-live-files.js";
 import type { ProfileManifest } from "../types/index.js";
 
 const MANIFEST: ProfileManifest = {
@@ -686,7 +683,7 @@ function git(cwd: string, ...args: string[]) {
 	);
 }
 
-describe("generated files git still tracks", () => {
+describe("generated files git still tracks: written, and warned about", () => {
 	/** A repo that committed profiles.json AND settings.json, like magus-src. */
 	async function commitTrackedSettings(): Promise<void> {
 		expect(git(project, "init", "-q").status).toBe(0);
@@ -698,61 +695,63 @@ describe("generated files git still tracks", () => {
 		expect(git(project, "commit", "-q", "-m", "init").status).toBe(0);
 	}
 
-	/** Everything B1 says must not change when magus refuses. */
-	async function untouched(): Promise<void> {
-		expect(git(project, "status", "--porcelain").stdout).toBe("");
-		expect(await fs.pathExists(join(project, ".claude", "profiles"))).toBe(
-			false,
-		);
-		expect(await fs.pathExists(backupRoot(project))).toBe(false);
-		expect(await fs.pathExists(join(project, ".gitignore"))).toBe(false);
-	}
+	/** magus never runs git: nothing is staged, whatever it wrote. */
+	const nothingStaged = () =>
+		expect(git(project, "diff", "--cached", "--name-only").stdout).toBe("");
+
+	const WARNING =
+		".claude/settings.json is generated from .claude/profiles.json but tracked by git — run `git rm --cached .claude/settings.json`, then commit";
 
-	test("B1: activating over a tracked settings.json writes nothing and names the fix", async () => {
+	test("B7: activating over a tracked settings.json writes it and names the fix", async () => {
 		await commitTrackedSettings();
 
-		const error = await activateProfile(MANIFEST, "team", project, {
+		const result = await activateProfile(MANIFEST, "team", project, {
 			onDisplace: () => {},
-		}).then(
-			() => null,
-			(e: unknown) => e,
-		);
+		});
 
-		expect(error).toBeInstanceOf(TrackedLiveFileError);
-		const message = (error as Error).message;
-		expect(message).toContain(".claude/settings.json");
-		expect(message).toContain("git rm --cached .claude/settings.json");
-		expect(message).toContain("Nothing was changed.");
-		await untouched();
+		expect(result.tracked).toEqual([".claude/settings.json"]);
+		expect(activationNotes(result)).toContain(WARNING);
+		expect((await fs.readJson(settingsPath())).enabledPlugins).toEqual({
+			"dev@magus": true,
+			"terminal@magus": false,
+		});
+		expect((await readActiveMarker(project))?.profile).toBe("team");
+		expect(git(project, "status", "--porcelain").stdout).toContain(
+			" M .claude/settings.json",
+		);
+		nothingStaged();
 	});
 
-	test("B1: the gate, the switch path and a startup choice all refuse, writing nothing", async () => {
+	test("B7: the gate, the switch path and a startup choice all write", async () => {
 		await commitTrackedSettings();
 
-		const prep = await prepareProfileState(project);
-		expect(prep.refusal).toBeInstanceOf(TrackedLiveFileError);
-		expect(prep.problems[0]).toContain("git rm --cached .claude/settings.json");
-		expect(await profileGate(project)).toBe(false);
-
-		const switched = await switchToProfile(project, "other", {
-			onDisplace: () => {},
-		});
-		expect(switched.activation).toBeNull();
-		expect(switched.problems[0]).toContain(".claude/settings.json");
-
 		for (const choice of [
 			{ kind: "activate", id: "team" },
 			{ kind: "adopt", id: "default-2" },
 		] as const) {
-			await expect(
-				applyProfileChoice(choice, MANIFEST, project, { onDisplace: () => {} }),
-			).rejects.toBeInstanceOf(TrackedLiveFileError);
+			const result = await applyProfileChoice(choice, MANIFEST, project, {
+				onDisplace: () => {},
+			});
+			expect(result.profileId).toBe(choice.id);
 		}
-		await untouched();
+		const prep = await prepareProfileState(project);
+		expect(prep.problems).toEqual([]);
+		expect(await profileGate(project)).toBe(true);
+
+		const switched = await switchToProfile(project, "other", {
+			onDisplace: () => {},
+		});
+		expect(switched.problems).toEqual([]);
+		expect(switched.activation?.profileId).toBe("other");
+		expect(
+			(await fs.readJson(settingsPath())).enabledPlugins["terminal@magus"],
+		).toBe(true);
+		nothingStaged();
 	});
 
-	test("B1: the CLI router exits 1 for `magus profile switch`, and writes nothing", async () => {
+	test("B7: `magus profile switch` exits 0 and warns once, running no git", async () => {
 		await commitTrackedSettings();
+		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
 		const cwd = process.cwd();
 		process.chdir(project);
 		let outcome: Awaited<ReturnType<typeof route>>;
@@ -761,63 +760,47 @@ describe("generated files git still tracks", () => {
 		} finally {
 			process.chdir(cwd);
 		}
-		expect(outcome.exitCode).toBe(1);
-		expect(printed()).toContain("git rm --cached .claude/settings.json");
-		await untouched();
+		expect(outcome.exitCode).toBe(0);
+		expect(printed().split(WARNING).length - 1).toBe(1);
+		expect((await readActiveMarker(project))?.profile).toBe("other");
+		nothingStaged();
+	});
+
+	test("B7: `magus update` warns once about a tracked generated file, running no git", async () => {
+		await commitTrackedSettings();
+		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
+		// A named profile that does not exist: the command stops right after the
+		// warning, before anything reaches the network.
+		expect(await runUpdateCommand(["no-such-profile"], project)).toBe(1);
+		expect(printed().split(WARNING).length - 1).toBe(1);
+		nothingStaged();
 	});
 
-	test("B1: once settings.json is tracked, a pulled change regenerates nothing", async () => {
+	test("B7: once settings.json is tracked, a pulled change is still regenerated", async () => {
 		expect(git(project, "init", "-q").status).toBe(0);
 		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
 		// Somebody commits the generated file after all.
 		git(project, "add", "-f", ".claude/settings.json");
 		git(project, "add", ".claude/profiles.json");
 		expect(git(project, "commit", "-q", "-m", "oops").status).toBe(0);
-		const before = await fs.readFile(settingsPath(), "utf8");
 		// A teammate's pull changes the profile.
 		const pulled = structuredClone(MANIFEST);
 		(pulled.profiles.team as { plugins: Record<string, string> }).plugins[
 			"mnemex@magus"
 		] = "latest";
 		await writeManifest(pulled, project);
-		const manifestBefore = await fs.readFile(
-			join(project, ".claude", "profiles.json"),
-			"utf8",
-		);
 
 		const prep = await prepareProfileState(project);
-		expect(prep.problems[0]).toContain("git rm --cached .claude/settings.json");
-		expect((await reconcileActiveProfile(project)).problems[0]).toContain(
-			".claude/settings.json",
-		);
-		await expect(regenerateLiveFiles(project)).rejects.toBeInstanceOf(
-			TrackedLiveFileError,
-		);
-		expect(await fs.readFile(settingsPath(), "utf8")).toBe(before);
-		expect(
-			await fs.readFile(join(project, ".claude", "profiles.json"), "utf8"),
-		).toBe(manifestBefore);
-	});
 
-	test("B1: after `git rm --cached` and a commit, activation proceeds and keeps the committed profiles.json", async () => {
-		await commitTrackedSettings();
-		git(project, "rm", "-q", "--cached", ".claude/settings.json");
-		expect(git(project, "commit", "-q", "-m", "untrack").status).toBe(0);
-		const manifestBytes = await fs.readFile(
-			join(project, ".claude", "profiles.json"),
-			"utf8",
-		);
-
-		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
-
-		expect((await lstat(settingsPath())).isFile()).toBe(true);
-		expect((await readActiveMarker(project))?.profile).toBe("team");
+		expect(prep.problems).toEqual([]);
+		expect(prep.lines.join("\n")).toContain("regenerated");
 		expect(
-			await fs.readFile(join(project, ".claude", "profiles.json"), "utf8"),
-		).toBe(manifestBytes);
+			(await fs.readJson(settingsPath())).enabledPlugins["mnemex@magus"],
+		).toBe(true);
+		nothingStaged();
 	});
 
-	test("B1: adopting a repo with no profiles.json and a tracked settings.json writes nothing", async () => {
+	test("B7: adopting a repo with no profiles.json and a tracked settings.json writes and warns", async () => {
 		await fs.remove(join(project, ".claude", "profiles.json"));
 		expect(git(project, "init", "-q").status).toBe(0);
 		await fs.outputJson(settingsPath(), {
@@ -829,112 +812,112 @@ describe("generated files git still tracks", () => {
 		const savedHome = process.env.HOME;
 		process.env.HOME = home;
 		try {
-			await expect(
-				ensureManifest(project, { allowAdopt: true }),
-			).rejects.toBeInstanceOf(TrackedLiveFileError);
+			expect(
+				await ensureManifest(project, { allowAdopt: true }),
+			).not.toBeNull();
 		} finally {
 			process.env.HOME = savedHome;
 			await rm(home, { recursive: true, force: true });
 		}
-		expect(await fs.pathExists(join(project, ".claude", "profiles.json"))).toBe(
-			false,
+		const manifest = await readManifest(project);
+		expect(Object.keys(manifest.profiles)).toHaveLength(1);
+		expect(await activeProfile(project)).toBe(
+			Object.keys(manifest.profiles)[0],
 		);
-		await untouched();
+		expect(printed()).toContain(WARNING);
+		nothingStaged();
 	});
 
-	test("B1: doctor counts a tracked live file as a problem", async () => {
+	test("B7: doctor notes a tracked live file with the fix, and does not count it", async () => {
 		await commitTrackedSettings();
+		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
 		const counts = await reportProfileState(project, false);
-		expect(counts.unfixable).toBeGreaterThan(0);
-		expect(printed()).toContain("git rm --cached .claude/settings.json");
-		await untouched();
+		expect(counts.unfixable).toBe(0);
+		expect(printed()).toContain(`• ${WARNING}`);
 	});
 
-	test("review M1: writeSettings and writeMcpConfig refuse a tracked live file and leave it as it is", async () => {
+	test("B7: writeSettings and writeMcpConfig write a tracked live file", async () => {
 		await commitTrackedSettings();
 		await fs.outputJson(join(project, ".mcp.json"), { mcpServers: {} });
 		git(project, "add", ".mcp.json");
 		expect(git(project, "commit", "-q", "-m", "mcp").status).toBe(0);
-		const before = await fs.readFile(settingsPath(), "utf8");
 
 		// What the TUI Profiles tab's "apply predefined" does.
 		const settings = await readSettings(project);
-		(settings.enabledPlugins as Record<string, boolean>)["frontend@magus"] =
-			true;
-		await expect(writeSettings(settings, project)).rejects.toBeInstanceOf(
-			TrackedLiveFileError,
-		);
-		await expect(
-			writeMcpConfig({ mcpServers: { x: { command: "x" } } }, project),
-		).rejects.toBeInstanceOf(TrackedLiveFileError);
-
-		expect(await fs.readFile(settingsPath(), "utf8")).toBe(before);
-		await untouched();
-	});
-
-	test("review M1: a project-scope Claude CLI install or uninstall is refused before the CLI runs", async () => {
-		await commitTrackedSettings();
-		const cwd = process.cwd();
-		const pathBefore = process.env.PATH;
-		// git stays reachable; `claude` does not — were the refusal missing, the
-		// CLI could not run here and touch this machine's plugins anyway.
-		const gitDir = spawnSync("sh", ["-c", "command -v git"], {
-			encoding: "utf8",
-		}).stdout.trim();
-		process.env.PATH = gitDir.slice(0, gitDir.lastIndexOf("/"));
-		process.chdir(project);
-		try {
-			await expect(
-				installPlugin("dev@magus", "project"),
-			).rejects.toBeInstanceOf(TrackedLiveFileError);
-			await expect(
-				uninstallPlugin("dev@magus", "project", project),
-			).rejects.toBeInstanceOf(TrackedLiveFileError);
-		} finally {
-			process.chdir(cwd);
-			process.env.PATH = pathBefore;
-		}
-		await untouched();
-	});
-
-	test("review M1: a project without profiles writes its own settings.json as before", async () => {
-		await commitTrackedSettings();
-		await writeManifest({ version: 2, profiles: {} }, project);
-		const settings = await readSettings(project);
 		(settings.enabledPlugins as Record<string, boolean>)["frontend@magus"] =
 			true;
 		await writeSettings(settings, project);
+		await writeMcpConfig({ mcpServers: { x: { command: "x" } } }, project);
+
 		expect(
 			(await fs.readJson(settingsPath())).enabledPlugins["frontend@magus"],
 		).toBe(true);
+		expect((await fs.readJson(join(project, ".mcp.json"))).mcpServers).toEqual({
+			x: { command: "x" },
+		});
+		nothingStaged();
 	});
 
-	test("review 3a: inside a work tree git cannot read, activation refuses with git's own message", async () => {
+	test("B7: inside a work tree git cannot read, activation writes and says git could not be asked", async () => {
 		// A .git pointing at a repository that is not there: git exits 128.
 		await fs.outputFile(
 			join(project, ".git"),
 			`gitdir: ${join(project, "no-such-repository")}\n`,
 		);
 
-		const error = await activateProfile(MANIFEST, "team", project, {
+		const result = await activateProfile(MANIFEST, "team", project, {
 			onDisplace: () => {},
-		}).then(
-			() => null,
-			(e: unknown) => e,
+		});
+
+		expect(await fs.pathExists(settingsPath())).toBe(true);
+		expect(typeof result.tracked).toBe("string");
+		expect(activationNotes(result).join("\n")).toContain(
+			"magus could not check which files git tracks in this project",
 		);
+		expect((await prepareProfileState(project)).problems).toEqual([]);
+	});
 
-		expect(error).toBeInstanceOf(GitCheckError);
-		expect((error as Error).message).toContain("not a git repository");
-		expect((error as Error).message).toContain("Nothing was changed.");
-		expect(await fs.pathExists(settingsPath())).toBe(false);
-		expect(await fs.pathExists(join(project, ".claude", "profiles"))).toBe(
-			false,
+	test("B7 review L3: converting an older layout where git cannot answer exits 1 with git's message, no stack trace", async () => {
+		// 7.4.1 layout, a listed skill linked: the conversion must ask git which
+		// skill folders the team committed. `--dry-run` skips the entry gate, so
+		// the error reaches the router's own handler.
+		const withSkill = structuredClone(MANIFEST);
+		(withSkill.profiles.team as { skills: unknown[] }).skills = [
+			{ name: "alpha", repo: "a/b", path: "skills/alpha" },
+		];
+		await writeManifest(withSkill, project);
+		const old = join(project, ".claude", "_profiles", "team");
+		await fs.outputFile(join(old, "skills", "alpha", "SKILL.md"), "# alpha\n");
+		await fs.outputJson(join(old, "settings.json"), {
+			enabledPlugins: { "dev@magus": true },
+		});
+		await fs.symlink("_profiles/team/settings.json", settingsPath());
+		await fs.symlink(
+			"_profiles/team/skills",
+			join(project, ".claude", "skills"),
+		);
+		await fs.outputFile(
+			join(project, ".git"),
+			`gitdir: ${join(project, "no-such-repository")}\n`,
+		);
+		const cwd = process.cwd();
+		process.chdir(project);
+		let outcome: Awaited<ReturnType<typeof route>>;
+		try {
+			outcome = await route(
+				["profile", "switch", "team", "--dry-run"],
+				"0.0.0-test",
+			);
+		} finally {
+			process.chdir(cwd);
+		}
+		expect(outcome.exitCode).toBe(1);
+		expect(printed()).toContain(
+			"magus could not check which files git tracks in this project. git said:",
 		);
-		const prep = await prepareProfileState(project);
-		expect(prep.refusal).toBeInstanceOf(GitCheckError);
 	});
 
-	test("review 3a: git missing is a refusal inside a work tree, and no check outside one", async () => {
+	test("git missing is an error inside a work tree, and no check outside one", async () => {
 		expect(git(project, "init", "-q").status).toBe(0);
 		const outside = await mkdtemp(join(tmpdir(), "no-git-"));
 		const pathBefore = process.env.PATH;

package/src/__tests__/stale-load-repair.test.ts

@@ -1180,3 +1180,163 @@ describe("B4: an update brings the loader forward in the same run", () => {
 		expect(await backups()).toEqual([]);
 	});
 });
+
+describe("7.5.2: Claude Code 2.1.281 updates another project's row of the repository", () => {
+	/**
+	 * `claude plugin update --scope project` as 2.1.281 does it: the FIRST row
+	 * relevant to the repository moves to `version` — here, the main tree's —
+	 * and this worktree's own row stays where it was.
+	 */
+	async function cli281(version: string): Promise<void> {
+		const registry = await readRegistry();
+		const rows = registry.plugins[PLUGIN];
+		const first = pickLoadedEntry(rows, here) as InstalledPluginEntry;
+		first.version = version;
+		first.installPath = cacheFor(version);
+		await fs.outputJson(registryFile, registry, { spaces: 2 });
+	}
+
+	/** The real registry, rewrite and loader question, against this root. */
+	function deps(version: string): PluginApplyDeps {
+		return {
+			install: async () => {},
+			update: async () => cli281(version),
+			repair: async () => {},
+			readInstalled: async () =>
+				(await readRegistry()).plugins[PLUGIN].find(
+					(e) => e.projectPath === here,
+				)?.version ?? null,
+			saveInstalled: async () => {},
+			registryRows: async () => (await readRegistry()).plugins[PLUGIN],
+			repairStaleLoad: (id, target, projectPath) =>
+				repairStaleLoad(id, target, projectPath, root),
+			loadedVersion: (id, projectPath) =>
+				loadedVersionHere(id, projectPath, root),
+		};
+	}
+
+	const item = (target: string) => ({
+		pluginId: PLUGIN,
+		pinned: "latest",
+		installed: "0.4.0",
+		available: target,
+		target,
+		action: "update" as const,
+		reason: "behind" as const,
+		scopes: ["project" as const],
+		beforeVersions: { project: "0.4.0" },
+	});
+
+	function collect() {
+		const details: string[] = [];
+		return {
+			details,
+			reporter: {
+				begin: () => {},
+				finish: (_ok: boolean, _name: string, detail: string) =>
+					details.push(detail),
+				detach: <T>(work: () => T) => work(),
+			},
+		};
+	}
+
+	test("7.5.2: this worktree's row follows to the version the CLI fetched, and the update says where it wrote", async () => {
+		await writeRegistry([
+			row({ version: "0.4.0", projectPath: mainTree }),
+			row({ version: "0.4.0", projectPath: here }),
+		]);
+		const { details, reporter } = collect();
+
+		const result = await applyPlugins(
+			[item("0.5.0")],
+			here,
+			deps("0.5.0"),
+			reporter,
+		);
+
+		expect(result.ok).toBe(1);
+		expect(result.unchanged).toEqual([]);
+		expect(
+			(await readRegistry()).plugins[PLUGIN].map((e) => [
+				e.projectPath,
+				e.version,
+			]),
+		).toEqual([
+			[mainTree, "0.5.0"],
+			[here, "0.5.0"],
+		]);
+		expect(details).toEqual([
+			`project → 0.5.0 · Claude Code updated ${mainTree} instead of this project — moved this project's record to v0.5.0 too`,
+		]);
+		expect(await loadedVersionHere(PLUGIN, here, root)).toBe("0.5.0");
+	});
+
+	test("7.5.2 review: a row of an UNRELATED repository moving during the update is not followed", async () => {
+		const other = path.join(base, "unrelated-752");
+		await fs.ensureDir(other);
+		git(other, "init", "-q");
+		await writeRegistry([
+			row({ version: "0.4.0", projectPath: other }),
+			row({ version: "0.4.0", projectPath: here }),
+		]);
+		const { details, reporter } = collect();
+		const unrelated: PluginApplyDeps = {
+			...deps("0.5.0"),
+			// Another repository's session updates its own row meanwhile.
+			update: async () => {
+				const registry = await readRegistry();
+				const moved = registry.plugins[PLUGIN].find(
+					(e) => e.projectPath === other,
+				) as InstalledPluginEntry;
+				moved.version = "0.5.0";
+				moved.installPath = cacheFor("0.5.0");
+				await fs.outputJson(registryFile, registry, { spaces: 2 });
+			},
+		};
+
+		const result = await applyPlugins(
+			[item("0.5.0")],
+			here,
+			unrelated,
+			reporter,
+		);
+
+		expect(result.unchanged).toEqual([PLUGIN]);
+		expect(
+			(await readRegistry()).plugins[PLUGIN].map((e) => [
+				e.projectPath,
+				e.version,
+			]),
+		).toEqual([
+			[other, "0.5.0"],
+			[here, "0.4.0"],
+		]);
+		expect(details).toEqual([
+			`no change — the installer exited 0 but ${PLUGIN} is still 0.4.0`,
+		]);
+	});
+
+	test("7.5.2: a version with no cache directory is not followed — no change, and why", async () => {
+		await writeRegistry([
+			row({ version: "0.4.0", projectPath: mainTree }),
+			row({ version: "0.4.0", projectPath: here }),
+		]);
+		const { details, reporter } = collect();
+
+		const result = await applyPlugins(
+			[item("0.6.0")],
+			here,
+			deps("0.6.0"),
+			reporter,
+		);
+
+		expect(result.unchanged).toEqual([PLUGIN]);
+		expect(
+			(await readRegistry()).plugins[PLUGIN].find((e) => e.projectPath === here)
+				?.version,
+		).toBe("0.4.0");
+		expect(details[0]).toContain(
+			`no change — the installer exited 0 but ${PLUGIN} is still 0.4.0 (Claude Code updated ${mainTree} instead of this project, and this project's record could not follow: no cache directory for v0.6.0`,
+		);
+	});
+});