claudeup 4.10.1 → 4.11.0

package/src/__tests__/plugin-version-check.test.ts

@@ -0,0 +1,760 @@
+/**
+ * Tests for plugin version mismatch detection and fix.
+ *
+ * Claude Code's plugin loader (pluginLoader.ts:2051) takes entries[0]
+ * from installed_plugins.json regardless of project scope. When
+ * different projects install different versions, only the one at
+ * index [0] loads for ALL projects.
+ *
+ * Each test uses a real temp filesystem with mocked os.homedir().
+ */
+
+import {
+	afterAll,
+	afterEach,
+	beforeEach,
+	describe,
+	expect,
+	it,
+	mock,
+} from "bun:test";
+import path from "node:path";
+import fs from "fs-extra";
+
+// Grab real os before mocking
+const realOs = await import("node:os");
+const realTmpdir = realOs.tmpdir();
+
+// Initialize tmpHome eagerly so module-level os.homedir() calls in
+// claude-settings.ts (for INSTALLED_PLUGINS_FILE, KNOWN_MARKETPLACES_FILE)
+// get a valid path during import. The mock closure reads this variable.
+//
+// IMPORTANT: INSTALLED_PLUGINS_FILE is a constant set once at module load
+// using os.homedir(). It will always point to initTmpHome. So we must
+// write installed_plugins.json to initTmpHome and use the same tmpHome
+// for ALL tests (cleaning up between tests).
+const initTmpHome = fs.mkdtempSync(path.join(realTmpdir, "vmcheck-init-"));
+let tmpHome: string = initTmpHome;
+let tmpProjectA: string;
+let tmpProjectB: string;
+
+/** Write global settings at <tmpHome>/.claude/settings.json */
+async function writeGlobalSettings(settings: Record<string, unknown>) {
+	const dir = path.join(tmpHome, ".claude");
+	await fs.ensureDir(dir);
+	await fs.writeJson(path.join(dir, "settings.json"), settings, { spaces: 2 });
+}
+
+/** Write project settings at <projectPath>/.claude/settings.json */
+async function writeProjectSettings(
+	projectPath: string,
+	settings: Record<string, unknown>,
+) {
+	const dir = path.join(projectPath, ".claude");
+	await fs.ensureDir(dir);
+	await fs.writeJson(path.join(dir, "settings.json"), settings, { spaces: 2 });
+}
+
+/**
+ * Write installed_plugins.json.
+ * INSTALLED_PLUGINS_FILE constant was set at module load using os.homedir()
+ * which returned initTmpHome. We must always write there.
+ */
+async function writeInstalledPlugins(registry: Record<string, unknown>) {
+	const dir = path.join(initTmpHome, ".claude", "plugins");
+	await fs.ensureDir(dir);
+	await fs.writeJson(path.join(dir, "installed_plugins.json"), registry, {
+		spaces: 2,
+	});
+}
+
+/** Read installed_plugins.json back from disk (from initTmpHome) */
+async function readInstalledPluginsFromDisk(): Promise<
+	Record<string, unknown>
+> {
+	const p = path.join(
+		initTmpHome,
+		".claude",
+		"plugins",
+		"installed_plugins.json",
+	);
+	if (await fs.pathExists(p)) {
+		return fs.readJson(p);
+	}
+	return {};
+}
+
+/** Clean installed_plugins.json between tests */
+async function cleanInstalledPlugins() {
+	const p = path.join(
+		initTmpHome,
+		".claude",
+		"plugins",
+		"installed_plugins.json",
+	);
+	await fs.remove(p);
+}
+
+// Mock os.homedir() — hoisted before import.
+// tmpHome is used for global settings (read at runtime via os.homedir()),
+// initTmpHome is used for INSTALLED_PLUGINS_FILE (set once at module load).
+// We keep tmpHome = initTmpHome so both global settings and installed_plugins
+// share the same .claude directory.
+mock.module("node:os", () => {
+	const mocked = { ...realOs, homedir: () => tmpHome };
+	return {
+		...mocked,
+		default: mocked,
+	};
+});
+
+// Import functions under test AFTER mock registration
+const {
+	checkPluginVersionMismatches,
+	checkSinglePluginMismatch,
+	fixPluginVersionMismatch,
+	fixAllPluginVersionMismatches,
+	formatMismatchWarning,
+	formatMismatchBanner,
+} = await import("../services/plugin-version-check.js");
+
+// ── Test suite ───────────────────────────────────────────────────────────────
+
+describe("checkPluginVersionMismatches", () => {
+	beforeEach(async () => {
+		// Keep tmpHome = initTmpHome so INSTALLED_PLUGINS_FILE and global
+		// settings share the same .claude directory
+		tmpHome = initTmpHome;
+		tmpProjectA = await fs.mkdtemp(path.join(realTmpdir, "vmcheck-projA-"));
+		tmpProjectB = await fs.mkdtemp(path.join(realTmpdir, "vmcheck-projB-"));
+		await fs.ensureDir(path.join(tmpHome, ".claude"));
+		await fs.ensureDir(path.join(tmpHome, ".claude", "plugins"));
+		await cleanInstalledPlugins();
+	});
+
+	afterEach(async () => {
+		await cleanInstalledPlugins();
+		// Clean global settings between tests
+		const globalSettingsPath = path.join(tmpHome, ".claude", "settings.json");
+		await fs.remove(globalSettingsPath);
+		await fs.remove(tmpProjectA);
+		await fs.remove(tmpProjectB);
+	});
+
+	afterAll(async () => {
+		await fs.remove(initTmpHome).catch(() => {});
+	});
+
+	it("detects mismatch when entries[0] has a different version than current project", async () => {
+		// Project A was installed first (at index 0) with v2.0.0
+		// Project B (current) has v4.0.2
+		await writeGlobalSettings({
+			enabledPlugins: { "terminal@magus": true },
+		});
+		await writeProjectSettings(tmpProjectB, {
+			enabledPlugins: { "terminal@magus": true },
+		});
+		await writeInstalledPlugins({
+			version: 2,
+			plugins: {
+				"terminal@magus": [
+					{
+						scope: "project",
+						projectPath: tmpProjectA,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/2.0.0`,
+						version: "2.0.0",
+						installedAt: "2025-01-01T00:00:00.000Z",
+						lastUpdated: "2025-01-01T00:00:00.000Z",
+					},
+					{
+						scope: "project",
+						projectPath: tmpProjectB,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/4.0.2`,
+						version: "4.0.2",
+						installedAt: "2025-03-01T00:00:00.000Z",
+						lastUpdated: "2025-03-01T00:00:00.000Z",
+					},
+				],
+			},
+		});
+
+		const mismatches = await checkPluginVersionMismatches(tmpProjectB);
+
+		expect(mismatches).toHaveLength(1);
+		expect(mismatches[0].pluginId).toBe("terminal@magus");
+		expect(mismatches[0].firstEntryVersion).toBe("2.0.0");
+		expect(mismatches[0].currentProjectVersion).toBe("4.0.2");
+		expect(mismatches[0].firstEntryProject).toBe(tmpProjectA);
+	});
+
+	it("returns empty when entries[0] matches current project version", async () => {
+		await writeGlobalSettings({
+			enabledPlugins: { "terminal@magus": true },
+		});
+		await writeProjectSettings(tmpProjectA, {
+			enabledPlugins: { "terminal@magus": true },
+		});
+		await writeInstalledPlugins({
+			version: 2,
+			plugins: {
+				"terminal@magus": [
+					{
+						scope: "project",
+						projectPath: tmpProjectA,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/4.0.2`,
+						version: "4.0.2",
+						installedAt: "2025-01-01T00:00:00.000Z",
+						lastUpdated: "2025-01-01T00:00:00.000Z",
+					},
+					{
+						scope: "project",
+						projectPath: tmpProjectB,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/4.0.2`,
+						version: "4.0.2",
+						installedAt: "2025-03-01T00:00:00.000Z",
+						lastUpdated: "2025-03-01T00:00:00.000Z",
+					},
+				],
+			},
+		});
+
+		const mismatches = await checkPluginVersionMismatches(tmpProjectA);
+
+		expect(mismatches).toEqual([]);
+	});
+
+	it("returns empty when plugin has only one entry", async () => {
+		await writeGlobalSettings({
+			enabledPlugins: { "terminal@magus": true },
+		});
+		await writeProjectSettings(tmpProjectA, {
+			enabledPlugins: { "terminal@magus": true },
+		});
+		await writeInstalledPlugins({
+			version: 2,
+			plugins: {
+				"terminal@magus": [
+					{
+						scope: "project",
+						projectPath: tmpProjectA,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/4.0.2`,
+						version: "4.0.2",
+						installedAt: "2025-01-01T00:00:00.000Z",
+						lastUpdated: "2025-01-01T00:00:00.000Z",
+					},
+				],
+			},
+		});
+
+		const mismatches = await checkPluginVersionMismatches(tmpProjectA);
+
+		expect(mismatches).toEqual([]);
+	});
+
+	it("returns empty when current project has no entry in registry", async () => {
+		await writeGlobalSettings({
+			enabledPlugins: { "terminal@magus": true },
+		});
+		await writeProjectSettings(tmpProjectB, {
+			enabledPlugins: { "terminal@magus": true },
+		});
+		await writeInstalledPlugins({
+			version: 2,
+			plugins: {
+				"terminal@magus": [
+					{
+						scope: "project",
+						projectPath: tmpProjectA,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/2.0.0`,
+						version: "2.0.0",
+						installedAt: "2025-01-01T00:00:00.000Z",
+						lastUpdated: "2025-01-01T00:00:00.000Z",
+					},
+				],
+			},
+		});
+
+		// tmpProjectB is enabled but has no registry entry — no mismatch detectable
+		const mismatches = await checkPluginVersionMismatches(tmpProjectB);
+
+		expect(mismatches).toEqual([]);
+	});
+
+	it("detects multiple mismatched plugins", async () => {
+		await writeGlobalSettings({
+			enabledPlugins: {
+				"terminal@magus": true,
+				"dev@magus": true,
+			},
+		});
+		await writeProjectSettings(tmpProjectB, {
+			enabledPlugins: {
+				"terminal@magus": true,
+				"dev@magus": true,
+			},
+		});
+		await writeInstalledPlugins({
+			version: 2,
+			plugins: {
+				"terminal@magus": [
+					{
+						scope: "project",
+						projectPath: tmpProjectA,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/2.0.0`,
+						version: "2.0.0",
+						installedAt: "2025-01-01T00:00:00.000Z",
+						lastUpdated: "2025-01-01T00:00:00.000Z",
+					},
+					{
+						scope: "project",
+						projectPath: tmpProjectB,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/4.0.2`,
+						version: "4.0.2",
+						installedAt: "2025-03-01T00:00:00.000Z",
+						lastUpdated: "2025-03-01T00:00:00.000Z",
+					},
+				],
+				"dev@magus": [
+					{
+						scope: "project",
+						projectPath: tmpProjectA,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/dev/1.0.0`,
+						version: "1.0.0",
+						installedAt: "2025-01-01T00:00:00.000Z",
+						lastUpdated: "2025-01-01T00:00:00.000Z",
+					},
+					{
+						scope: "project",
+						projectPath: tmpProjectB,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/dev/2.7.0`,
+						version: "2.7.0",
+						installedAt: "2025-03-01T00:00:00.000Z",
+						lastUpdated: "2025-03-01T00:00:00.000Z",
+					},
+				],
+			},
+		});
+
+		const mismatches = await checkPluginVersionMismatches(tmpProjectB);
+
+		expect(mismatches).toHaveLength(2);
+		const terminalMismatch = mismatches.find(
+			(m) => m.pluginId === "terminal@magus",
+		);
+		const devMismatch = mismatches.find((m) => m.pluginId === "dev@magus");
+
+		expect(terminalMismatch).toBeDefined();
+		expect(terminalMismatch?.firstEntryVersion).toBe("2.0.0");
+		expect(terminalMismatch?.currentProjectVersion).toBe("4.0.2");
+
+		expect(devMismatch).toBeDefined();
+		expect(devMismatch?.firstEntryVersion).toBe("1.0.0");
+		expect(devMismatch?.currentProjectVersion).toBe("2.7.0");
+	});
+
+	it("skips plugins not enabled for the project", async () => {
+		// Plugin is in registry but not enabled
+		await writeGlobalSettings({
+			enabledPlugins: {},
+		});
+		await writeProjectSettings(tmpProjectB, {
+			enabledPlugins: {},
+		});
+		await writeInstalledPlugins({
+			version: 2,
+			plugins: {
+				"terminal@magus": [
+					{
+						scope: "project",
+						projectPath: tmpProjectA,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/2.0.0`,
+						version: "2.0.0",
+						installedAt: "2025-01-01T00:00:00.000Z",
+						lastUpdated: "2025-01-01T00:00:00.000Z",
+					},
+					{
+						scope: "project",
+						projectPath: tmpProjectB,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/4.0.2`,
+						version: "4.0.2",
+						installedAt: "2025-03-01T00:00:00.000Z",
+						lastUpdated: "2025-03-01T00:00:00.000Z",
+					},
+				],
+			},
+		});
+
+		const mismatches = await checkPluginVersionMismatches(tmpProjectB);
+
+		expect(mismatches).toEqual([]);
+	});
+
+	it("handles empty installed_plugins.json gracefully", async () => {
+		await writeGlobalSettings({
+			enabledPlugins: { "terminal@magus": true },
+		});
+		await writeProjectSettings(tmpProjectA, {
+			enabledPlugins: { "terminal@magus": true },
+		});
+		// No installed_plugins.json written
+
+		const mismatches = await checkPluginVersionMismatches(tmpProjectA);
+
+		expect(mismatches).toEqual([]);
+	});
+});
+
+describe("checkSinglePluginMismatch", () => {
+	beforeEach(async () => {
+		tmpHome = initTmpHome;
+		tmpProjectA = await fs.mkdtemp(path.join(realTmpdir, "vmcheck-projA-"));
+		tmpProjectB = await fs.mkdtemp(path.join(realTmpdir, "vmcheck-projB-"));
+		await fs.ensureDir(path.join(tmpHome, ".claude"));
+		await fs.ensureDir(path.join(tmpHome, ".claude", "plugins"));
+		await cleanInstalledPlugins();
+	});
+
+	afterEach(async () => {
+		await cleanInstalledPlugins();
+		await fs.remove(tmpProjectA);
+		await fs.remove(tmpProjectB);
+	});
+
+	it("returns mismatch info for a single plugin", async () => {
+		await writeInstalledPlugins({
+			version: 2,
+			plugins: {
+				"terminal@magus": [
+					{
+						scope: "project",
+						projectPath: tmpProjectA,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/2.0.0`,
+						version: "2.0.0",
+						installedAt: "2025-01-01T00:00:00.000Z",
+						lastUpdated: "2025-01-01T00:00:00.000Z",
+					},
+					{
+						scope: "project",
+						projectPath: tmpProjectB,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/4.0.2`,
+						version: "4.0.2",
+						installedAt: "2025-03-01T00:00:00.000Z",
+						lastUpdated: "2025-03-01T00:00:00.000Z",
+					},
+				],
+			},
+		});
+
+		const mismatch = await checkSinglePluginMismatch(
+			"terminal@magus",
+			tmpProjectB,
+		);
+
+		expect(mismatch).not.toBeNull();
+		expect(mismatch?.firstEntryVersion).toBe("2.0.0");
+		expect(mismatch?.currentProjectVersion).toBe("4.0.2");
+	});
+
+	it("returns null when no mismatch", async () => {
+		await writeInstalledPlugins({
+			version: 2,
+			plugins: {
+				"terminal@magus": [
+					{
+						scope: "project",
+						projectPath: tmpProjectA,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/4.0.2`,
+						version: "4.0.2",
+						installedAt: "2025-01-01T00:00:00.000Z",
+						lastUpdated: "2025-01-01T00:00:00.000Z",
+					},
+					{
+						scope: "project",
+						projectPath: tmpProjectB,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/4.0.2`,
+						version: "4.0.2",
+						installedAt: "2025-03-01T00:00:00.000Z",
+						lastUpdated: "2025-03-01T00:00:00.000Z",
+					},
+				],
+			},
+		});
+
+		const mismatch = await checkSinglePluginMismatch(
+			"terminal@magus",
+			tmpProjectB,
+		);
+
+		expect(mismatch).toBeNull();
+	});
+});
+
+describe("fixPluginVersionMismatch", () => {
+	beforeEach(async () => {
+		tmpHome = initTmpHome;
+		tmpProjectA = await fs.mkdtemp(path.join(realTmpdir, "vmcheck-projA-"));
+		tmpProjectB = await fs.mkdtemp(path.join(realTmpdir, "vmcheck-projB-"));
+		await fs.ensureDir(path.join(tmpHome, ".claude"));
+		await fs.ensureDir(path.join(tmpHome, ".claude", "plugins"));
+		await cleanInstalledPlugins();
+	});
+
+	afterEach(async () => {
+		await cleanInstalledPlugins();
+		await fs.remove(tmpProjectA);
+		await fs.remove(tmpProjectB);
+	});
+
+	it("updates all entries to the target version", async () => {
+		const cachePath402 = `${tmpHome}/.claude/plugins/cache/magus/terminal/4.0.2`;
+
+		await writeInstalledPlugins({
+			version: 2,
+			plugins: {
+				"terminal@magus": [
+					{
+						scope: "project",
+						projectPath: tmpProjectA,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/2.0.0`,
+						version: "2.0.0",
+						installedAt: "2025-01-01T00:00:00.000Z",
+						lastUpdated: "2025-01-01T00:00:00.000Z",
+					},
+					{
+						scope: "project",
+						projectPath: tmpProjectB,
+						installPath: cachePath402,
+						version: "4.0.2",
+						installedAt: "2025-03-01T00:00:00.000Z",
+						lastUpdated: "2025-03-01T00:00:00.000Z",
+					},
+				],
+			},
+		});
+
+		const result = await fixPluginVersionMismatch("terminal@magus", "4.0.2");
+
+		expect(result.updated).toBe(1);
+		expect(result.projects).toHaveLength(1);
+
+		// Verify the registry was updated on disk
+		const registry = await readInstalledPluginsFromDisk();
+		const plugins = registry.plugins as Record<
+			string,
+			Array<Record<string, string>>
+		>;
+		const entries = plugins["terminal@magus"];
+
+		expect(entries).toHaveLength(2);
+		expect(entries[0].version).toBe("4.0.2");
+		expect(entries[0].installPath).toBe(cachePath402);
+		expect(entries[1].version).toBe("4.0.2");
+		expect(entries[1].installPath).toBe(cachePath402);
+	});
+
+	it("returns zero updates when all entries already match", async () => {
+		await writeInstalledPlugins({
+			version: 2,
+			plugins: {
+				"terminal@magus": [
+					{
+						scope: "project",
+						projectPath: tmpProjectA,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/4.0.2`,
+						version: "4.0.2",
+						installedAt: "2025-01-01T00:00:00.000Z",
+						lastUpdated: "2025-01-01T00:00:00.000Z",
+					},
+					{
+						scope: "project",
+						projectPath: tmpProjectB,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/4.0.2`,
+						version: "4.0.2",
+						installedAt: "2025-03-01T00:00:00.000Z",
+						lastUpdated: "2025-03-01T00:00:00.000Z",
+					},
+				],
+			},
+		});
+
+		const result = await fixPluginVersionMismatch("terminal@magus", "4.0.2");
+
+		expect(result.updated).toBe(0);
+		expect(result.projects).toEqual([]);
+	});
+
+	it("returns zero updates when target version not found in entries", async () => {
+		await writeInstalledPlugins({
+			version: 2,
+			plugins: {
+				"terminal@magus": [
+					{
+						scope: "project",
+						projectPath: tmpProjectA,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/2.0.0`,
+						version: "2.0.0",
+						installedAt: "2025-01-01T00:00:00.000Z",
+						lastUpdated: "2025-01-01T00:00:00.000Z",
+					},
+				],
+			},
+		});
+
+		const result = await fixPluginVersionMismatch("terminal@magus", "9.9.9");
+
+		expect(result.updated).toBe(0);
+		expect(result.projects).toEqual([]);
+	});
+
+	it("returns zero updates for unknown plugin", async () => {
+		await writeInstalledPlugins({
+			version: 2,
+			plugins: {},
+		});
+
+		const result = await fixPluginVersionMismatch("unknown@mp", "1.0.0");
+
+		expect(result.updated).toBe(0);
+		expect(result.projects).toEqual([]);
+	});
+});
+
+describe("fixAllPluginVersionMismatches", () => {
+	beforeEach(async () => {
+		tmpHome = initTmpHome;
+		tmpProjectA = await fs.mkdtemp(path.join(realTmpdir, "vmcheck-projA-"));
+		tmpProjectB = await fs.mkdtemp(path.join(realTmpdir, "vmcheck-projB-"));
+		await fs.ensureDir(path.join(tmpHome, ".claude"));
+		await fs.ensureDir(path.join(tmpHome, ".claude", "plugins"));
+		await cleanInstalledPlugins();
+	});
+
+	afterEach(async () => {
+		await cleanInstalledPlugins();
+		await fs.remove(tmpProjectA);
+		await fs.remove(tmpProjectB);
+	});
+
+	it("fixes multiple mismatches in a single write", async () => {
+		const termCachePath = `${tmpHome}/.claude/plugins/cache/magus/terminal/4.0.2`;
+		const devCachePath = `${tmpHome}/.claude/plugins/cache/magus/dev/2.7.0`;
+
+		await writeInstalledPlugins({
+			version: 2,
+			plugins: {
+				"terminal@magus": [
+					{
+						scope: "project",
+						projectPath: tmpProjectA,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/terminal/2.0.0`,
+						version: "2.0.0",
+						installedAt: "2025-01-01T00:00:00.000Z",
+						lastUpdated: "2025-01-01T00:00:00.000Z",
+					},
+					{
+						scope: "project",
+						projectPath: tmpProjectB,
+						installPath: termCachePath,
+						version: "4.0.2",
+						installedAt: "2025-03-01T00:00:00.000Z",
+						lastUpdated: "2025-03-01T00:00:00.000Z",
+					},
+				],
+				"dev@magus": [
+					{
+						scope: "project",
+						projectPath: tmpProjectA,
+						installPath: `${tmpHome}/.claude/plugins/cache/magus/dev/1.0.0`,
+						version: "1.0.0",
+						installedAt: "2025-01-01T00:00:00.000Z",
+						lastUpdated: "2025-01-01T00:00:00.000Z",
+					},
+					{
+						scope: "project",
+						projectPath: tmpProjectB,
+						installPath: devCachePath,
+						version: "2.7.0",
+						installedAt: "2025-03-01T00:00:00.000Z",
+						lastUpdated: "2025-03-01T00:00:00.000Z",
+					},
+				],
+			},
+		});
+
+		const mismatches = [
+			{
+				pluginId: "terminal@magus",
+				firstEntryVersion: "2.0.0",
+				firstEntryProject: tmpProjectA,
+				currentProjectVersion: "4.0.2",
+				allEntries: [],
+			},
+			{
+				pluginId: "dev@magus",
+				firstEntryVersion: "1.0.0",
+				firstEntryProject: tmpProjectA,
+				currentProjectVersion: "2.7.0",
+				allEntries: [],
+			},
+		];
+
+		const results = await fixAllPluginVersionMismatches(mismatches);
+
+		expect(results.size).toBe(2);
+		expect(results.get("terminal@magus")?.updated).toBe(1);
+		expect(results.get("dev@magus")?.updated).toBe(1);
+
+		// Verify on disk
+		const registry = await readInstalledPluginsFromDisk();
+		const plugins = registry.plugins as Record<
+			string,
+			Array<Record<string, string>>
+		>;
+		expect(plugins["terminal@magus"][0].version).toBe("4.0.2");
+		expect(plugins["terminal@magus"][0].installPath).toBe(termCachePath);
+		expect(plugins["dev@magus"][0].version).toBe("2.7.0");
+		expect(plugins["dev@magus"][0].installPath).toBe(devCachePath);
+	});
+});
+
+describe("formatMismatchWarning", () => {
+	it("formats warning text with plugin details and bug link", () => {
+		const mismatches = [
+			{
+				pluginId: "terminal@magus",
+				firstEntryVersion: "2.0.0",
+				firstEntryProject: "/Users/test/project-a",
+				currentProjectVersion: "4.0.2",
+				allEntries: [],
+			},
+		];
+
+		const warning = formatMismatchWarning(mismatches);
+
+		expect(warning).toContain("terminal@magus");
+		expect(warning).toContain("v2.0.0");
+		expect(warning).toContain("v4.0.2");
+		expect(warning).toContain("#45997");
+		expect(warning).toContain("claudeup");
+	});
+});
+
+describe("formatMismatchBanner", () => {
+	it("formats concise banner text", () => {
+		const mismatches = [
+			{
+				pluginId: "terminal@magus",
+				firstEntryVersion: "2.0.0",
+				firstEntryProject: "/Users/test/project-a",
+				currentProjectVersion: "4.0.2",
+				allEntries: [],
+			},
+		];
+
+		const banner = formatMismatchBanner(mismatches);
+
+		expect(banner).toContain("terminal@magus");
+		expect(banner).toContain("v2.0.0");
+		expect(banner).toContain("v4.0.2");
+	});
+});