claudeup 6.2.1 → 6.3.0

package/src/__tests__/dual-write-prevention.test.ts

@@ -11,14 +11,14 @@
  *   but NOT when CLI is unavailable or update fails (no phantom state).
  */
 
-import { describe, it, expect, mock, beforeEach, afterEach } from "bun:test";
+import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as url from "node:url";
+import * as actualClaudeCli from "../services/claude-cli.js";
 // Real modules captured before the mock.module() overrides below, so the mocks
 // can spread the full export surface instead of stripping it.
 import * as actualClaudeSettings from "../services/claude-settings.js";
-import * as actualClaudeCli from "../services/claude-cli.js";
 import * as actualPluginManager from "../services/plugin-manager.js";
 
 // ---------------------------------------------------------------------------
@@ -34,55 +34,55 @@ import * as actualPluginManager from "../services/plugin-manager.js";
 
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 const PLUGINS_SCREEN_PATH = path.resolve(
-  __dirname,
-  "../ui/screens/PluginsScreen.tsx",
+	__dirname,
+	"../ui/screens/PluginsScreen.tsx",
 );
 
 describe("PluginsScreen — no dual-write after CLI operations", () => {
-  let source: string;
-
-  beforeEach(() => {
-    source = fs.readFileSync(PLUGINS_SCREEN_PATH, "utf8");
-  });
-
-  it("does not call saveVersionAfterInstall immediately after cliUpdatePlugin", () => {
-    // Find every occurrence of cliUpdatePlugin in the source. Each one should
-    // NOT be immediately followed (within 3 lines) by saveVersionAfterInstall.
-    const lines = source.split("\n");
-    const violations: number[] = [];
-
-    for (let i = 0; i < lines.length; i++) {
-      if (lines[i].includes("cliUpdatePlugin(")) {
-        // Check the next 3 lines for a dual-write call
-        for (let j = i + 1; j <= Math.min(i + 3, lines.length - 1); j++) {
-          if (lines[j].includes("saveVersionAfterInstall(")) {
-            violations.push(i + 1); // 1-indexed line number
-            break;
-          }
-        }
-      }
-    }
-
-    expect(violations).toEqual([]);
-  });
-
-  it("does not call saveVersionAfterInstall immediately after cliInstallPlugin", () => {
-    const lines = source.split("\n");
-    const violations: number[] = [];
-
-    for (let i = 0; i < lines.length; i++) {
-      if (lines[i].includes("cliInstallPlugin(")) {
-        for (let j = i + 1; j <= Math.min(i + 3, lines.length - 1); j++) {
-          if (lines[j].includes("saveVersionAfterInstall(")) {
-            violations.push(i + 1);
-            break;
-          }
-        }
-      }
-    }
-
-    expect(violations).toEqual([]);
-  });
+	let source: string;
+
+	beforeEach(() => {
+		source = fs.readFileSync(PLUGINS_SCREEN_PATH, "utf8");
+	});
+
+	it("does not call saveVersionAfterInstall immediately after cliUpdatePlugin", () => {
+		// Find every occurrence of cliUpdatePlugin in the source. Each one should
+		// NOT be immediately followed (within 3 lines) by saveVersionAfterInstall.
+		const lines = source.split("\n");
+		const violations: number[] = [];
+
+		for (let i = 0; i < lines.length; i++) {
+			if (lines[i].includes("cliUpdatePlugin(")) {
+				// Check the next 3 lines for a dual-write call
+				for (let j = i + 1; j <= Math.min(i + 3, lines.length - 1); j++) {
+					if (lines[j].includes("saveVersionAfterInstall(")) {
+						violations.push(i + 1); // 1-indexed line number
+						break;
+					}
+				}
+			}
+		}
+
+		expect(violations).toEqual([]);
+	});
+
+	it("does not call saveVersionAfterInstall immediately after cliInstallPlugin", () => {
+		const lines = source.split("\n");
+		const violations: number[] = [];
+
+		for (let i = 0; i < lines.length; i++) {
+			if (lines[i].includes("cliInstallPlugin(")) {
+				for (let j = i + 1; j <= Math.min(i + 3, lines.length - 1); j++) {
+					if (lines[j].includes("saveVersionAfterInstall(")) {
+						violations.push(i + 1);
+						break;
+					}
+				}
+			}
+		}
+
+		expect(violations).toEqual([]);
+	});
 });
 
 // ---------------------------------------------------------------------------
@@ -108,92 +108,91 @@ let mockGetAvailablePlugins: ReturnType<typeof mock>;
 // bindings are evaluated before these mock.module() calls run, so they capture
 // the real modules.
 mock.module("../services/claude-settings.js", () => ({
-  ...actualClaudeSettings,
-  recoverMarketplaceSettings: mock(() =>
-    Promise.resolve({ enabledAutoUpdate: [], removed: [], reregistered: [] }),
-  ),
-  migrateMarketplaceRename: mock(() =>
-    Promise.resolve({
-      projectMigrated: 0,
-      globalMigrated: 0,
-      localMigrated: 0,
-      registryMigrated: 0,
-      knownMarketplacesMigrated: false,
-    }),
-  ),
-  getGlobalEnabledPlugins: mock(() => Promise.resolve({})),
-  getEnabledPlugins: mock(() => Promise.resolve({})),
-  getLocalEnabledPlugins: mock(() => Promise.resolve({})),
-  saveGlobalInstalledPluginVersion: (...args: unknown[]) =>
-    mockSaveGlobal(...args),
-  saveLocalInstalledPluginVersion: (...args: unknown[]) =>
-    mockSaveLocal(...args),
-  readGlobalSettings: mock(() => Promise.resolve({ hooks: {} })),
-  writeGlobalSettings: mock(() => Promise.resolve()),
+	...actualClaudeSettings,
+	recoverMarketplaceSettings: mock(() =>
+		Promise.resolve({ enabledAutoUpdate: [], removed: [], reregistered: [] }),
+	),
+	migrateMarketplaceRename: mock(() =>
+		Promise.resolve({
+			projectMigrated: 0,
+			globalMigrated: 0,
+			localMigrated: 0,
+			registryMigrated: 0,
+			knownMarketplacesMigrated: false,
+		}),
+	),
+	getGlobalEnabledPlugins: mock(() => Promise.resolve({})),
+	getEnabledPlugins: mock(() => Promise.resolve({})),
+	getLocalEnabledPlugins: mock(() => Promise.resolve({})),
+	saveGlobalInstalledPluginVersion: (...args: unknown[]) =>
+		mockSaveGlobal(...args),
+	saveLocalInstalledPluginVersion: (...args: unknown[]) =>
+		mockSaveLocal(...args),
+	readGlobalSettings: mock(() => Promise.resolve({ hooks: {} })),
+	writeGlobalSettings: mock(() => Promise.resolve()),
 }));
 
 mock.module("../services/claude-cli.js", () => ({
-  ...actualClaudeCli,
-  updatePlugin: (...args: unknown[]) => mockUpdatePlugin(...args),
-  repairPlugin: (...args: unknown[]) => mockRepairPlugin(...args),
-  isClaudeAvailable: (...args: unknown[]) => mockIsClaudeAvailable(...args),
-  addMarketplace: mock(() => Promise.resolve()),
-  updateMarketplace: mock(() => Promise.resolve()),
+	...actualClaudeCli,
+	updatePlugin: (...args: unknown[]) => mockUpdatePlugin(...args),
+	repairPlugin: (...args: unknown[]) => mockRepairPlugin(...args),
+	isClaudeAvailable: (...args: unknown[]) => mockIsClaudeAvailable(...args),
+	addMarketplace: mock(() => Promise.resolve()),
+	updateMarketplace: mock(() => Promise.resolve()),
 }));
 
 mock.module("../services/plugin-manager.js", () => ({
-  ...actualPluginManager,
-  getAvailablePlugins: (...args: unknown[]) =>
-    mockGetAvailablePlugins(...args),
-  saveInstalledPluginVersion: (...args: unknown[]) => mockSaveProject(...args),
-  clearMarketplaceCache: mock(() => undefined),
+	...actualPluginManager,
+	getAvailablePlugins: (...args: unknown[]) => mockGetAvailablePlugins(...args),
+	saveInstalledPluginVersion: (...args: unknown[]) => mockSaveProject(...args),
+	clearMarketplaceCache: mock(() => undefined),
 }));
 
 mock.module("../services/update-cache.js", () => ({
-  UpdateCache: class {
-    shouldCheckForUpdates = mock(() => Promise.resolve(true));
-    saveCheck = mock(() => Promise.resolve());
-  },
+	UpdateCache: class {
+		shouldCheckForUpdates = mock(() => Promise.resolve(true));
+		saveCheck = mock(() => Promise.resolve());
+	},
 }));
 
 mock.module("../services/claude-runner.js", () => ({
-  runClaude: mock(() => Promise.resolve(0)),
+	runClaude: mock(() => Promise.resolve(0)),
 }));
 
 mock.module("../data/marketplaces.js", () => ({
-  defaultMarketplaces: [],
+	defaultMarketplaces: [],
 }));
 
 mock.module("../utils/string-utils.js", () => ({
-  parsePluginId: mock((_id: string) => null),
+	parsePluginId: mock((_id: string) => null),
 }));
 
 mock.module("fs-extra", () => ({
-  default: {
-    pathExists: mock(() => Promise.resolve(false)),
-    readJson: mock(() => Promise.resolve({})),
-    writeJson: mock(() => Promise.resolve()),
-    ensureDir: mock(() => Promise.resolve()),
-  },
+	default: {
+		pathExists: mock(() => Promise.resolve(false)),
+		readJson: mock(() => Promise.resolve({})),
+		writeJson: mock(() => Promise.resolve()),
+		ensureDir: mock(() => Promise.resolve()),
+	},
 }));
 
 // Now import the module under test (after mock.module registrations).
 const { prerunClaude } = await import("../prerunner/index.js");
 
 interface ScopeStatusLike {
-  enabled: boolean;
-  version?: string;
+	enabled: boolean;
+	version?: string;
 }
 interface PluginLike {
-  id: string;
-  enabled: boolean;
-  hasUpdate: boolean;
-  contentStale?: boolean;
-  installedVersion: string;
-  version: string;
-  userScope?: ScopeStatusLike;
-  projectScope?: ScopeStatusLike;
-  localScope?: ScopeStatusLike;
+	id: string;
+	enabled: boolean;
+	hasUpdate: boolean;
+	contentStale?: boolean;
+	installedVersion: string;
+	version: string;
+	userScope?: ScopeStatusLike;
+	projectScope?: ScopeStatusLike;
+	localScope?: ScopeStatusLike;
 }
 
 /**
@@ -202,184 +201,180 @@ interface PluginLike {
  * no scope status describes a plugin installed nowhere and is correctly skipped.
  */
 function makePlugin(overrides: Partial<PluginLike> = {}): PluginLike {
-  return {
-    id: "test-plugin@magus",
-    enabled: true,
-    hasUpdate: true,
-    installedVersion: "1.0.0",
-    version: "1.1.0",
-    userScope: { enabled: true, version: "1.0.0" },
-    ...overrides,
-  };
+	return {
+		id: "test-plugin@magus",
+		enabled: true,
+		hasUpdate: true,
+		installedVersion: "1.0.0",
+		version: "1.1.0",
+		userScope: { enabled: true, version: "1.0.0" },
+		...overrides,
+	};
 }
 
 describe("prerunner — saveGlobalInstalledPluginVersion call count", () => {
-  beforeEach(() => {
-    mockSaveGlobal = mock(() => Promise.resolve());
-    mockSaveProject = mock(() => Promise.resolve());
-    mockSaveLocal = mock(() => Promise.resolve());
-    mockUpdatePlugin = mock(() => Promise.resolve());
-    mockRepairPlugin = mock(() => Promise.resolve());
-    mockIsClaudeAvailable = mock(() => Promise.resolve(true));
-    mockGetAvailablePlugins = mock(() =>
-      Promise.resolve([makePlugin()]),
-    );
-  });
-
-  it("calls saveGlobalInstalledPluginVersion once after successful CLI update", async () => {
-    // CLI is available, updatePlugin succeeds.
-    // The CLI does NOT update installedPluginVersions, so claudeup must save
-    // the version after a successful update.
-    mockIsClaudeAvailable = mock(() => Promise.resolve(true));
-    mockUpdatePlugin = mock(() => Promise.resolve());
-
-    await prerunClaude(["--help"], { force: true });
-
-    expect(mockSaveGlobal).toHaveBeenCalledTimes(1);
-  });
-
-  /**
-   * The prerunner used to call `updatePlugin(id, "user")` unconditionally.
-   * `hasUpdate` is computed from the CURRENT PROJECT's resolved version, but
-   * installs live per project in installed_plugins.json — 495 of 496 magus
-   * installs on the reporter's machine are project-scoped. So it detected
-   * project drift, updated user scope, reported success, and left the project
-   * untouched, re-detecting the identical drift on every subsequent run.
-   */
-  it("updates the PROJECT scope when that is where the outdated install is", async () => {
-    mockGetAvailablePlugins = mock(() =>
-      Promise.resolve([
-        makePlugin({
-          userScope: undefined,
-          projectScope: { enabled: true, version: "1.0.0" },
-        }),
-      ]),
-    );
-
-    await prerunClaude(["--help"], { force: true });
-
-    expect(mockUpdatePlugin).toHaveBeenCalledTimes(1);
-    expect(mockUpdatePlugin.mock.calls[0]?.[1]).toBe("project");
-    expect(mockSaveProject).toHaveBeenCalledTimes(1);
-    expect(mockSaveGlobal).toHaveBeenCalledTimes(0);
-  });
-
-  it("updates every scope that is outdated, not just the first", async () => {
-    mockGetAvailablePlugins = mock(() =>
-      Promise.resolve([
-        makePlugin({
-          userScope: { enabled: true, version: "1.0.0" },
-          projectScope: { enabled: true, version: "1.0.0" },
-          localScope: { enabled: true, version: "1.1.0" }, // already current
-        }),
-      ]),
-    );
-
-    await prerunClaude(["--help"], { force: true });
-
-    const scopes = mockUpdatePlugin.mock.calls
-      .map((c: unknown[]) => c[1])
-      .sort();
-    expect(scopes).toEqual(["project", "user"]);
-    expect(mockSaveLocal).toHaveBeenCalledTimes(0);
-  });
-
-  /**
-   * A content-stale plugin has no version bump to install over, and
-   * `claude plugin install` no-ops on "already installed" (verified against the
-   * real marketplace in autotest/plugin-system/probe-05). The prerunner must
-   * therefore repair — uninstall+install — not update.
-   */
-  it("repairs a content-stale plugin instead of updating it", async () => {
-    mockGetAvailablePlugins = mock(() =>
-      Promise.resolve([
-        makePlugin({
-          hasUpdate: false,
-          contentStale: true,
-          installedVersion: "1.0.0",
-          version: "1.0.0",
-          userScope: undefined,
-          projectScope: { enabled: true, version: "1.0.0" },
-        }),
-      ]),
-    );
-
-    await prerunClaude(["--help"], { force: true });
-
-    expect(mockRepairPlugin).toHaveBeenCalledTimes(1);
-    expect(mockRepairPlugin.mock.calls[0]?.[1]).toBe("project");
-    expect(mockUpdatePlugin).toHaveBeenCalledTimes(0);
-  });
-
-  it("prefers a real version update over a repair when both apply", async () => {
-    // A pending version bump reinstalls the files anyway, so repairing as well
-    // would double the work and the uninstall window.
-    mockGetAvailablePlugins = mock(() =>
-      Promise.resolve([
-        makePlugin({ hasUpdate: true, contentStale: true }),
-      ]),
-    );
-
-    await prerunClaude(["--help"], { force: true });
-
-    expect(mockUpdatePlugin).toHaveBeenCalledTimes(1);
-    expect(mockRepairPlugin).toHaveBeenCalledTimes(0);
-  });
-
-  it("does not repair when the CLI is unavailable", async () => {
-    mockIsClaudeAvailable = mock(() => Promise.resolve(false));
-    mockGetAvailablePlugins = mock(() =>
-      Promise.resolve([
-        makePlugin({
-          hasUpdate: false,
-          contentStale: true,
-          version: "1.0.0",
-          projectScope: { enabled: true, version: "1.0.0" },
-        }),
-      ]),
-    );
-
-    await prerunClaude(["--help"], { force: true });
-
-    expect(mockRepairPlugin).toHaveBeenCalledTimes(0);
-  });
-
-  it("does nothing when no scope holds an outdated install", async () => {
-    // hasUpdate can be true from a stale settings base while every real
-    // install is already current. Updating "somewhere" would be a guess.
-    mockGetAvailablePlugins = mock(() =>
-      Promise.resolve([
-        makePlugin({
-          userScope: { enabled: true, version: "1.1.0" },
-          projectScope: undefined,
-        }),
-      ]),
-    );
-
-    await prerunClaude(["--help"], { force: true });
-
-    expect(mockUpdatePlugin).toHaveBeenCalledTimes(0);
-    expect(mockSaveGlobal).toHaveBeenCalledTimes(0);
-  });
-
-  it("does NOT call saveGlobalInstalledPluginVersion when CLI is unavailable", async () => {
-    // CLI unavailable — we must NOT write phantom state.
-    mockIsClaudeAvailable = mock(() => Promise.resolve(false));
-
-    await prerunClaude(["--help"], { force: true });
-
-    expect(mockSaveGlobal).toHaveBeenCalledTimes(0);
-  });
-
-  it("does NOT call saveGlobalInstalledPluginVersion when CLI updatePlugin throws", async () => {
-    // CLI available but updatePlugin fails — must NOT write phantom state.
-    mockIsClaudeAvailable = mock(() => Promise.resolve(true));
-    mockUpdatePlugin = mock(() =>
-      Promise.reject(new Error("CLI update failed")),
-    );
-
-    await prerunClaude(["--help"], { force: true });
-
-    expect(mockSaveGlobal).toHaveBeenCalledTimes(0);
-  });
+	beforeEach(() => {
+		mockSaveGlobal = mock(() => Promise.resolve());
+		mockSaveProject = mock(() => Promise.resolve());
+		mockSaveLocal = mock(() => Promise.resolve());
+		mockUpdatePlugin = mock(() => Promise.resolve());
+		mockRepairPlugin = mock(() => Promise.resolve());
+		mockIsClaudeAvailable = mock(() => Promise.resolve(true));
+		mockGetAvailablePlugins = mock(() => Promise.resolve([makePlugin()]));
+	});
+
+	it("calls saveGlobalInstalledPluginVersion once after successful CLI update", async () => {
+		// CLI is available, updatePlugin succeeds.
+		// The CLI does NOT update installedPluginVersions, so claudeup must save
+		// the version after a successful update.
+		mockIsClaudeAvailable = mock(() => Promise.resolve(true));
+		mockUpdatePlugin = mock(() => Promise.resolve());
+
+		await prerunClaude(["--help"], { force: true });
+
+		expect(mockSaveGlobal).toHaveBeenCalledTimes(1);
+	});
+
+	/**
+	 * The prerunner used to call `updatePlugin(id, "user")` unconditionally.
+	 * `hasUpdate` is computed from the CURRENT PROJECT's resolved version, but
+	 * installs live per project in installed_plugins.json — 495 of 496 magus
+	 * installs on the reporter's machine are project-scoped. So it detected
+	 * project drift, updated user scope, reported success, and left the project
+	 * untouched, re-detecting the identical drift on every subsequent run.
+	 */
+	it("updates the PROJECT scope when that is where the outdated install is", async () => {
+		mockGetAvailablePlugins = mock(() =>
+			Promise.resolve([
+				makePlugin({
+					userScope: undefined,
+					projectScope: { enabled: true, version: "1.0.0" },
+				}),
+			]),
+		);
+
+		await prerunClaude(["--help"], { force: true });
+
+		expect(mockUpdatePlugin).toHaveBeenCalledTimes(1);
+		expect(mockUpdatePlugin.mock.calls[0]?.[1]).toBe("project");
+		expect(mockSaveProject).toHaveBeenCalledTimes(1);
+		expect(mockSaveGlobal).toHaveBeenCalledTimes(0);
+	});
+
+	it("updates every scope that is outdated, not just the first", async () => {
+		mockGetAvailablePlugins = mock(() =>
+			Promise.resolve([
+				makePlugin({
+					userScope: { enabled: true, version: "1.0.0" },
+					projectScope: { enabled: true, version: "1.0.0" },
+					localScope: { enabled: true, version: "1.1.0" }, // already current
+				}),
+			]),
+		);
+
+		await prerunClaude(["--help"], { force: true });
+
+		const scopes = mockUpdatePlugin.mock.calls
+			.map((c: unknown[]) => c[1])
+			.sort();
+		expect(scopes).toEqual(["project", "user"]);
+		expect(mockSaveLocal).toHaveBeenCalledTimes(0);
+	});
+
+	/**
+	 * A content-stale plugin has no version bump to install over, and
+	 * `claude plugin install` no-ops on "already installed" (verified against the
+	 * real marketplace in autotest/plugin-system/probe-05). The prerunner must
+	 * therefore repair — uninstall+install — not update.
+	 */
+	it("repairs a content-stale plugin instead of updating it", async () => {
+		mockGetAvailablePlugins = mock(() =>
+			Promise.resolve([
+				makePlugin({
+					hasUpdate: false,
+					contentStale: true,
+					installedVersion: "1.0.0",
+					version: "1.0.0",
+					userScope: undefined,
+					projectScope: { enabled: true, version: "1.0.0" },
+				}),
+			]),
+		);
+
+		await prerunClaude(["--help"], { force: true });
+
+		expect(mockRepairPlugin).toHaveBeenCalledTimes(1);
+		expect(mockRepairPlugin.mock.calls[0]?.[1]).toBe("project");
+		expect(mockUpdatePlugin).toHaveBeenCalledTimes(0);
+	});
+
+	it("prefers a real version update over a repair when both apply", async () => {
+		// A pending version bump reinstalls the files anyway, so repairing as well
+		// would double the work and the uninstall window.
+		mockGetAvailablePlugins = mock(() =>
+			Promise.resolve([makePlugin({ hasUpdate: true, contentStale: true })]),
+		);
+
+		await prerunClaude(["--help"], { force: true });
+
+		expect(mockUpdatePlugin).toHaveBeenCalledTimes(1);
+		expect(mockRepairPlugin).toHaveBeenCalledTimes(0);
+	});
+
+	it("does not repair when the CLI is unavailable", async () => {
+		mockIsClaudeAvailable = mock(() => Promise.resolve(false));
+		mockGetAvailablePlugins = mock(() =>
+			Promise.resolve([
+				makePlugin({
+					hasUpdate: false,
+					contentStale: true,
+					version: "1.0.0",
+					projectScope: { enabled: true, version: "1.0.0" },
+				}),
+			]),
+		);
+
+		await prerunClaude(["--help"], { force: true });
+
+		expect(mockRepairPlugin).toHaveBeenCalledTimes(0);
+	});
+
+	it("does nothing when no scope holds an outdated install", async () => {
+		// hasUpdate can be true from a stale settings base while every real
+		// install is already current. Updating "somewhere" would be a guess.
+		mockGetAvailablePlugins = mock(() =>
+			Promise.resolve([
+				makePlugin({
+					userScope: { enabled: true, version: "1.1.0" },
+					projectScope: undefined,
+				}),
+			]),
+		);
+
+		await prerunClaude(["--help"], { force: true });
+
+		expect(mockUpdatePlugin).toHaveBeenCalledTimes(0);
+		expect(mockSaveGlobal).toHaveBeenCalledTimes(0);
+	});
+
+	it("does NOT call saveGlobalInstalledPluginVersion when CLI is unavailable", async () => {
+		// CLI unavailable — we must NOT write phantom state.
+		mockIsClaudeAvailable = mock(() => Promise.resolve(false));
+
+		await prerunClaude(["--help"], { force: true });
+
+		expect(mockSaveGlobal).toHaveBeenCalledTimes(0);
+	});
+
+	it("does NOT call saveGlobalInstalledPluginVersion when CLI updatePlugin throws", async () => {
+		// CLI available but updatePlugin fails — must NOT write phantom state.
+		mockIsClaudeAvailable = mock(() => Promise.resolve(true));
+		mockUpdatePlugin = mock(() =>
+			Promise.reject(new Error("CLI update failed")),
+		);
+
+		await prerunClaude(["--help"], { force: true });
+
+		expect(mockSaveGlobal).toHaveBeenCalledTimes(0);
+	});
 });