magus-cli 7.4.1 → 7.5.1

package/src/__tests__/settings-file.test.ts

@@ -5,11 +5,9 @@
  * their configuration:
  *
  *  - an unparseable file must be REFUSED, and left byte-for-byte alone;
- *  - a symlinked settings.json must be written THROUGH the link, because that
- *    is the shape an active profile leaves behind (`.claude/settings.json` →
- *    `.claude/_profiles/<name>/settings.json`). Remove-then-create would
- *    replace the link with a plain file and detach the project from its
- *    profile, which nothing downstream would notice.
+ *  - a symlinked settings.json must be written THROUGH the link: a symlink a
+ *    person set up deliberately is theirs. Remove-then-create would replace
+ *    the link with a plain file, which nothing downstream would notice.
  */
 
 import { afterEach, describe, expect, test } from "bun:test";
@@ -154,7 +152,7 @@ describe("updateSettingsFile", () => {
 		expect(readFileSync(file, "utf8")).toBe(original);
 	});
 
-	test("S-6: a symlinked settings.json is written THROUGH the link — the profile case", async () => {
+	test("S-6: a symlinked settings.json is written THROUGH the link", async () => {
 		const dir = tempDir();
 		const target = path.join(dir, "profile-settings.json");
 		const link = path.join(dir, "settings.json");
@@ -168,7 +166,7 @@ describe("updateSettingsFile", () => {
 			settings.outputStyle = "composed";
 		});
 
-		// The profile's real file received the write …
+		// The link target received the write …
 		expect(JSON.parse(readFileSync(target, "utf8"))).toEqual({
 			enabledPlugins: { "dev@magus": true },
 			outputStyle: "composed",

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

@@ -13,6 +13,7 @@ import path from "node:path";
 import fs from "fs-extra";
 import {
 	findStaleLoads,
+	loadedVersionHere,
 	repairAllStaleLoads,
 	repairStaleLoad,
 	writeInstalledPluginsRegistry,
@@ -24,6 +25,11 @@ import {
 	repoRootForPath,
 	resolveLoadedVersions,
 } from "../services/plugin-resolution.js";
+import {
+	type PluginApplyDeps,
+	applyPlugins,
+	bringLoadForward,
+} from "../services/update-engine.js";
 import {
 	classifyPluginRows,
 	countPluginStates,
@@ -1075,3 +1081,102 @@ describe("repairAllStaleLoads", () => {
 		expect(await backups()).toEqual([]);
 	});
 });
+
+describe("B4: an update brings the loader forward in the same run", () => {
+	/**
+	 * `claude plugin update --scope project`, as far as the registry sees it:
+	 * this project's row moves to `version`, every other row stays.
+	 */
+	async function cliUpdateHere(version: string): Promise<void> {
+		const registry = await readRegistry();
+		registry.plugins[PLUGIN] = registry.plugins[PLUGIN].map((e) =>
+			e.projectPath === here
+				? { ...e, version, installPath: cacheFor(version) }
+				: e,
+		);
+		await fs.outputJson(registryFile, registry, { spaces: 2 });
+	}
+
+	/** The real repair and loader question, against this case's plugins root. */
+	function realDeps(): PluginApplyDeps {
+		return {
+			install: async () => {},
+			update: async () => cliUpdateHere("0.5.0"),
+			repair: async () => {},
+			readInstalled: async () => {
+				const rows = (await readRegistry()).plugins[PLUGIN];
+				return rows.find((e) => e.projectPath === here)?.version ?? null;
+			},
+			saveInstalled: async () => {},
+			repairStaleLoad: (id, target, projectPath) =>
+				repairStaleLoad(id, target, projectPath, root),
+			loadedVersion: (id, projectPath) =>
+				loadedVersionHere(id, projectPath, root),
+		};
+	}
+
+	test("B4: the deleted worktree's older row stops winning, and the update says so", async () => {
+		await writeRegistry([
+			row({ version: "0.3.0", projectPath: gone }),
+			row({ version: "0.4.0", projectPath: here }),
+		]);
+		const details: string[] = [];
+
+		const result = await applyPlugins(
+			[
+				{
+					pluginId: PLUGIN,
+					pinned: "latest",
+					installed: "0.4.0",
+					available: "0.5.0",
+					target: "0.5.0",
+					action: "update",
+					reason: "behind",
+					scopes: ["project"],
+					beforeVersions: { project: "0.4.0" },
+				},
+			],
+			here,
+			realDeps(),
+			{
+				begin: () => {},
+				finish: (_ok, _name, detail) => details.push(detail),
+				detach: (work) => work(),
+			},
+		);
+
+		expect(result.ok).toBe(1);
+		expect(result.failed).toEqual([]);
+		expect(details).toEqual([
+			"project → 0.5.0 · Claude Code now loads v0.5.0 here (1 older record moved forward)",
+		]);
+		expect(await loadedVersionHere(PLUGIN, here, root)).toBe("0.5.0");
+		// Moved forward, nothing removed.
+		expect(
+			(await readRegistry()).plugins[PLUGIN].map((e) => [
+				e.projectPath,
+				e.version,
+			]),
+		).toEqual([
+			[gone, "0.5.0"],
+			[here, "0.5.0"],
+		]);
+	});
+
+	test("B4: without the repair step the same update leaves the old version loading (negative control)", async () => {
+		await writeRegistry([
+			row({ version: "0.3.0", projectPath: gone }),
+			row({ version: "0.4.0", projectPath: here }),
+		]);
+		await cliUpdateHere("0.5.0");
+		expect(await loadedVersionHere(PLUGIN, here, root)).toBe("0.3.0");
+	});
+
+	test("B4: a loader already on the target is left alone — no write, no backup", async () => {
+		await writeRegistry([row({ version: "0.5.0", projectPath: here })]);
+		expect(
+			await bringLoadForward(PLUGIN, "0.5.0", here, realDeps()),
+		).toBeNull();
+		expect(await backups()).toEqual([]);
+	});
+});

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

@@ -4,6 +4,13 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import fs from "fs-extra";
 import { EMBEDDED_PRESETS } from "../data/styles/index.js";
+import { writeManifest } from "../services/manifest.js";
+import { activateProfile } from "../services/profile-activate.js";
+import {
+	liveHash,
+	readActiveMarker,
+	writeActiveMarker,
+} from "../services/profile-live.js";
 import {
 	INTEGRITY_BLOCK,
 	type ImportedStyle,
@@ -19,6 +26,7 @@ import {
 	splitFrontmatter,
 	validateSelection,
 } from "../services/styles-manager.js";
+import type { ProfileManifest } from "../types/index.js";
 import {
 	buildStyleBrowserItems,
 	firstSelectableIndex,
@@ -405,20 +413,26 @@ describe("applyStyles", () => {
 		).rejects.toThrow(/Nothing selected/);
 	});
 
-	test("writes THROUGH an active profile's settings symlink without breaking it", async () => {
-		// The regression this guards: removing-then-recreating settings.json
-		// silently detaches the project from its profile, and every later profile
-		// switch then writes to a file nothing reads.
-		const profileSettings = join(
+	const DEV: ProfileManifest = {
+		version: 2,
+		profiles: { dev: { name: "dev", plugins: {} } },
+	};
+
+	test("an older settings symlink is converted to a real file, not written through", async () => {
+		// Claude Code refuses to write through a symlink, so the style must not
+		// be applied by writing through one either: the file is rendered from
+		// the manifest in place of the link.
+		const oldSettings = join(
 			dir,
 			".claude",
 			"_profiles",
 			"dev",
 			"settings.json",
 		);
-		await fs.outputJson(profileSettings, { enabledPlugins: {} });
+		await fs.outputJson(oldSettings, { enabledPlugins: {} });
 		const link = join(dir, ".claude", "settings.json");
 		await symlink("_profiles/dev/settings.json", link);
+		await writeManifest(DEV, dir);
 
 		const result = await applyStyles({
 			projectPath: dir,
@@ -428,33 +442,13 @@ describe("applyStyles", () => {
 
 		expect(result.profile).toBe("dev");
 		expect(result.styleName).toBe("composed-dev");
-		expect((await fs.lstat(link)).isSymbolicLink()).toBe(true);
-		// The write landed in the profile, which is what "apply to the current
-		// profile" means.
-		expect((await fs.readJson(profileSettings)).outputStyle).toBe(
-			"composed-dev",
-		);
+		expect((await fs.lstat(link)).isSymbolicLink()).toBe(false);
+		expect((await fs.readJson(link)).outputStyle).toBe("composed-dev");
 	});
 
-	test("records the style in profiles.json so re-materializing cannot drop it", async () => {
-		// materializeProfile rewrites settings.json from the manifest, so a live
-		// write alone regresses on the next `magus install`.
-		const profileSettings = join(
-			dir,
-			".claude",
-			"_profiles",
-			"dev",
-			"settings.json",
-		);
-		await fs.outputJson(profileSettings, { enabledPlugins: {} });
-		await symlink(
-			"_profiles/dev/settings.json",
-			join(dir, ".claude", "settings.json"),
-		);
-		await fs.outputJson(join(dir, ".claude", "profiles.json"), {
-			version: 2,
-			profiles: { dev: { name: "dev", plugins: {} } },
-		});
+	test("with an activated profile, the live file stays real and is recorded", async () => {
+		await writeManifest(DEV, dir);
+		await activateProfile(DEV, "dev", dir, { onDisplace: () => {} });
 
 		const result = await applyStyles({
 			projectPath: dir,
@@ -462,67 +456,46 @@ describe("applyStyles", () => {
 			imports: [],
 		});
 
+		const live = join(dir, ".claude", "settings.json");
 		expect(result.recordedInManifest).toBe(true);
-		const manifest = await fs.readJson(join(dir, ".claude", "profiles.json"));
-		expect(manifest.profiles.dev.settings.outputStyle).toBe("composed-dev");
+		expect((await fs.lstat(live)).isFile()).toBe(true);
+		expect((await fs.readJson(live)).outputStyle).toBe("composed-dev");
+		// Rendered from the manifest and recorded, so it reads as unchanged.
+		expect((await readActiveMarker(dir))?.files.settings).toBe(
+			(await liveHash("settings", dir)) ?? "",
+		);
 	});
 
-	test("reports honestly when there is a profile but no manifest entry", async () => {
-		const profileSettings = join(
-			dir,
-			".claude",
-			"_profiles",
-			"dev",
-			"settings.json",
-		);
-		await fs.outputJson(profileSettings, {});
-		await symlink(
-			"_profiles/dev/settings.json",
-			join(dir, ".claude", "settings.json"),
-		);
+	test("records the style in profiles.json, where rendering reads it", async () => {
+		await writeManifest(DEV, dir);
+		await activateProfile(DEV, "dev", dir, { onDisplace: () => {} });
 
 		const result = await applyStyles({
 			projectPath: dir,
 			presets: [preset({ name: "direct" })],
 			imports: [],
 		});
-		expect(result.profile).toBe("dev");
-		expect(result.recordedInManifest).toBe(false);
-	});
-});
 
-describe("clearStyle", () => {
-	test("removes the key rather than setting it undefined", async () => {
-		await applyStyles({
-			projectPath: dir,
-			presets: [preset({ name: "direct" })],
-			imports: [],
-		});
-		await clearStyle(dir);
+		expect(result.recordedInManifest).toBe(true);
+		const manifest = await fs.readJson(join(dir, ".claude", "profiles.json"));
+		expect(manifest.profiles.dev.settings.outputStyle).toBe("composed-dev");
+	});
 
-		const raw = await fs.readFile(
-			join(dir, ".claude", "settings.json"),
-			"utf8",
+	test("a marker naming a profile profiles.json lacks is no active profile", async () => {
+		await writeManifest(DEV, dir);
+		await writeActiveMarker(
+			{ version: 1, profile: "gone", files: {}, skills: {} },
+			dir,
 		);
-		expect(raw).not.toContain("outputStyle");
-		expect(JSON.parse(raw)).toEqual({});
-	});
+		await fs.outputJson(join(dir, ".claude", "settings.json"), {});
 
-	test("leaves the generated file on disk so a re-apply is one keypress away", async () => {
 		const result = await applyStyles({
 			projectPath: dir,
 			presets: [preset({ name: "direct" })],
 			imports: [],
 		});
-		await clearStyle(dir);
-		expect(await fs.pathExists(result.stylePath)).toBe(true);
-	});
-
-	test("is a no-op on a project that never had a style", async () => {
-		await clearStyle(dir);
-		expect(await fs.pathExists(join(dir, ".claude", "settings.json"))).toBe(
-			false,
-		);
+		expect(result.profile).toBeNull();
+		expect(result.recordedInManifest).toBe(false);
 	});
 });
 

package/src/__tests__/styles-screen-state.test.ts

@@ -1,15 +1,18 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtemp, rm, symlink } from "node:fs/promises";
+import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { parseKeypress } from "@opentui/core";
 import fs from "fs-extra";
+import { writeManifest } from "../services/manifest.js";
+import { activateProfile } from "../services/profile-activate.js";
 import {
 	applyStyles,
 	clearStyle,
 	communityCacheDirOrNull,
 	loadStyles,
 } from "../services/styles-manager.js";
+import type { ProfileManifest } from "../types/index.js";
 import type { KeyPress } from "../ui/input/key-dispatch.js";
 import { SCREEN_BINDINGS, matchBinding } from "../ui/keymap.js";
 import { appReducer, initialState } from "../ui/state/reducer.js";
@@ -291,16 +294,14 @@ describe("loadStyles reports what is actually in force", () => {
 	});
 
 	test("looks for the per-profile style when a profile is active", async () => {
-		await fs.outputJson(
-			join(dir, ".claude", "_profiles", "dev", "settings.json"),
-			{
-				outputStyle: "composed-dev",
+		const manifest: ProfileManifest = {
+			version: 2,
+			profiles: {
+				dev: { name: "dev", settings: { outputStyle: "composed-dev" } },
 			},
-		);
-		await symlink(
-			"_profiles/dev/settings.json",
-			join(dir, ".claude", "settings.json"),
-		);
+		};
+		await writeManifest(manifest, dir);
+		await activateProfile(manifest, "dev", dir, { onDisplace: () => {} });
 		await fs.outputFile(
 			join(dir, ".claude", "output-styles", "composed-dev.md"),
 			"---\nname: composed-dev\nstyle-presets: terse\nstyle-imports: none\n---\n\nbody",

package/src/__tests__/support/preload.ts

@@ -0,0 +1,14 @@
+/**
+ * Loaded before every test file (bunfig.toml `[test] preload`).
+ *
+ * Rendering a profile reads each plugin's plugin.json to find its
+ * dependencies, from `~/.claude/plugins` — different on every machine, and
+ * absent on CI. Every test starts from "no plugin declares a dependency"; a
+ * test about dependencies installs its own reader and restores this one.
+ */
+
+import { setPluginDependencyReader } from "../../services/plugin-dependencies.js";
+
+export const NO_DEPENDENCIES = async (): Promise<string[]> => [];
+
+setPluginDependencyReader(NO_DEPENDENCIES);

package/src/__tests__/update-apply.test.ts

@@ -780,3 +780,148 @@ describe("applyPlugins — read-back against beforeVersions", () => {
 		expect(reasons.lines(["other@magus"])).toBe("other@magus");
 	});
 });
+
+// ── B4: installed must mean LOADED ──────────────────────────────────────────
+//
+// Claude Code's loader takes the FIRST registry row relevant to the repository,
+// and rows from this repository's other checkouts (deleted worktrees included)
+// often precede this project's own. `claude plugin update` writes only this
+// project's row, so an update could show "updated" and load the old version at
+// once. The same operation now runs the stale-load repair as its last step.
+
+describe("B4: an install or update ends with the loader on the new version", () => {
+	/** `loaded` is what the loader resolves until the repair has run. */
+	function loaderDeps(loaded: string | null, repairOk = true) {
+		const stub = stubDeps("2.0.0", (pluginId, target) =>
+			repairOk
+				? {
+						pluginId,
+						target,
+						rewritten: 3,
+						backup: "/tmp/installed_plugins.json.backup.1",
+						loaded: target,
+						ok: true,
+					}
+				: {
+						pluginId,
+						target,
+						rewritten: 0,
+						backup: null,
+						loaded,
+						ok: false,
+						error: `the loader still resolves v${loaded} here, not v${target}`,
+					},
+		);
+		stub.deps.loadedVersion = mock(async () => loaded);
+		return stub;
+	}
+
+	test("B4: an update the loader does not pick up moves the older records forward and says so", async () => {
+		const { deps, rowsRepaired } = loaderDeps("1.0.0");
+		const { reporter, rows } = recordingReporter();
+
+		const result = await applyPlugins([item({})], PROJECT, deps, reporter);
+
+		expect(rowsRepaired).toEqual([
+			{ id: "dev@magus", target: "2.0.0", projectPath: PROJECT },
+		]);
+		expect(result.ok).toBe(1);
+		expect(result.failed).toEqual([]);
+		expect(rows).toEqual([
+			{
+				ok: true,
+				name: "dev@magus",
+				detail:
+					"project → 2.0.0 · Claude Code now loads v2.0.0 here (3 older records moved forward)",
+			},
+		]);
+	});
+
+	test("B4: a loader already on the landed version runs no repair", async () => {
+		const { deps, rowsRepaired } = loaderDeps("2.0.0");
+		const { reporter, rows } = recordingReporter();
+
+		const result = await applyPlugins([item({})], PROJECT, deps, reporter);
+
+		expect(rowsRepaired).toEqual([]);
+		expect(result.ok).toBe(1);
+		expect(rows[0]?.detail).toBe("project → 2.0.0");
+	});
+
+	test("B4: a repair that cannot move the loader makes the update a failure, never 'updated'", async () => {
+		const { deps } = loaderDeps("1.0.0", false);
+		const { reporter, rows } = recordingReporter();
+
+		const result = await applyPlugins([item({})], PROJECT, deps, reporter);
+
+		expect(result.ok).toBe(0);
+		expect(result.failed).toEqual(["dev@magus"]);
+		expect(rows).toEqual([
+			{
+				ok: false,
+				name: "dev@magus",
+				detail:
+					"installed v2.0.0, but Claude Code still loads v1.0.0 here — the loader still resolves v1.0.0 here, not v2.0.0",
+			},
+		]);
+	});
+
+	test("B4: an install whose version did not move still brings the loader forward, and is not 'no change'", async () => {
+		// The project row already held 2.0.0; the older row ahead of it is what
+		// loaded. Reporting "no change" would leave the plugin loading 1.0.0.
+		const { deps, rowsRepaired } = loaderDeps("1.0.0");
+
+		const result = await applyPlugins(
+			[item({ beforeVersions: { project: "2.0.0" } })],
+			PROJECT,
+			deps,
+		);
+
+		expect(rowsRepaired).toHaveLength(1);
+		expect(result.unchanged).toEqual([]);
+		expect(result.ok).toBe(1);
+	});
+
+	test("B4: the TUI's per-scope install and update helpers repair at project scope", async () => {
+		const a = loaderDeps("1.0.0");
+		expect(
+			await updatePluginInScope("dev@magus", "project", PROJECT, a.deps),
+		).toBe("2.0.0");
+		expect(a.rowsRepaired).toEqual([
+			{ id: "dev@magus", target: "2.0.0", projectPath: PROJECT },
+		]);
+
+		const b = loaderDeps("1.0.0");
+		await installPluginInScope("dev@magus", "project", PROJECT, b.deps);
+		expect(b.rowsRepaired).toHaveLength(1);
+	});
+
+	test("B4: a per-scope helper whose repair fails throws, so the TUI reports a failure", async () => {
+		const { deps } = loaderDeps("1.0.0", false);
+		await expect(
+			updatePluginInScope("dev@magus", "project", PROJECT, deps),
+		).rejects.toThrow(
+			"installed v2.0.0, but Claude Code still loads v1.0.0 here",
+		);
+	});
+
+	test("B4: the per-scope helpers bring the loader forward at user and local scope too", async () => {
+		for (const scope of ["user", "local"] as const) {
+			const up = loaderDeps("1.0.0");
+			await updatePluginInScope("dev@magus", scope, PROJECT, up.deps);
+			expect(up.rowsRepaired).toEqual([
+				{ id: "dev@magus", target: "2.0.0", projectPath: PROJECT },
+			]);
+			const fresh = loaderDeps("1.0.0");
+			await installPluginInScope("dev@magus", scope, PROJECT, fresh.deps);
+			expect(fresh.rowsRepaired).toHaveLength(1);
+		}
+	});
+
+	test("B4: a machine-wide winner the repair refuses fails the user-scope update, naming why", async () => {
+		const { deps } = loaderDeps("1.0.0", false);
+		await expect(
+			updatePluginInScope("dev@magus", "user", PROJECT, deps),
+		).rejects.toThrow("the loader still resolves v1.0.0 here, not v2.0.0");
+	});
+});