claudeup 6.2.0 → 6.3.0

package/src/__tests__/plugin-setup.test.ts

@@ -6,15 +6,15 @@
  * and `required` setup keys.
  */
 
-import { describe, it, expect, mock, beforeEach, afterEach } from "bun:test";
-import { mkdtemp, mkdir, writeFile, chmod, rm } from "node:fs/promises";
+import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
+import * as actualChildProcess from "node:child_process";
+import { chmod, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 // Real modules captured before the mock.module() overrides, so the mocks spread
 // the full surface instead of stripping exports (e.g. resolveExecutable) that
 // bun's global, non-restored mock.module would otherwise remove for later files.
 import * as actualCommandUtils from "../utils/command-utils.js";
-import * as actualChildProcess from "node:child_process";
 
 // ---------------------------------------------------------------------------
 // Mocks — must be set up BEFORE any import from plugin-setup
@@ -86,6 +86,7 @@ const {
 	extractGoVersion,
 	extractBinaryName,
 	parseAtSpec,
+	parseGoSpec,
 	parsePipSpec,
 	goDepNeedsInstall,
 	goDepDecision,
@@ -119,14 +120,97 @@ describe("extractGoBinaryName", () => {
 	});
 
 	it("handles module with nested path and version", () => {
-		expect(
-			extractGoBinaryName("github.com/org/repo/cmd/mycli@v2.0.0"),
-		).toBe("mycli");
+		expect(extractGoBinaryName("github.com/org/repo/cmd/mycli@v2.0.0")).toBe(
+			"mycli",
+		);
 	});
 
 	it("handles empty string gracefully", () => {
 		expect(extractGoBinaryName("")).toBe("");
 	});
+
+	// Negative control for the /vN fix: a plain basename returns "v2" here.
+	// Without the go-module helper wired in, this test FAILS.
+	it("names the binary after the module, not its /v2 major-version suffix", () => {
+		expect(
+			extractGoBinaryName("github.com/MadAppGang/tmux-mcp/v2@v2.0.0"),
+		).toBe("tmux-mcp");
+	});
+
+	it("strips the /v2 suffix from an unpinned module path too", () => {
+		expect(extractGoBinaryName("github.com/MadAppGang/tmux-mcp/v2")).toBe(
+			"tmux-mcp",
+		);
+	});
+
+	it("keeps a name that merely starts with v2", () => {
+		expect(extractGoBinaryName("github.com/x/v2tool@v1.0.0")).toBe("v2tool");
+	});
+});
+
+// ---------------------------------------------------------------------------
+// 1b. parseGoSpec — the Go-specific view over parseAtSpec
+// ---------------------------------------------------------------------------
+
+describe("parseGoSpec", () => {
+	it("v1 module: name and pinned version", () => {
+		expect(parseGoSpec("github.com/MadAppGang/tmux-mcp@v1.7.1")).toEqual({
+			spec: "github.com/MadAppGang/tmux-mcp@v1.7.1",
+			name: "tmux-mcp",
+			version: "v1.7.1",
+		});
+	});
+
+	it("v2 module: the /v2 suffix is not the name, the version survives", () => {
+		expect(parseGoSpec("github.com/MadAppGang/tmux-mcp/v2@v2.0.0")).toEqual({
+			spec: "github.com/MadAppGang/tmux-mcp/v2@v2.0.0",
+			name: "tmux-mcp",
+			version: "v2.0.0",
+		});
+	});
+
+	it("v2 module without a pin: name resolved, version null", () => {
+		expect(parseGoSpec("github.com/MadAppGang/tmux-mcp/v2")).toEqual({
+			spec: "github.com/MadAppGang/tmux-mcp/v2",
+			name: "tmux-mcp",
+			version: null,
+		});
+	});
+
+	it("a segment that starts with v2 is a real name", () => {
+		expect(parseGoSpec("github.com/x/v2tool@v1.0.0")).toEqual({
+			spec: "github.com/x/v2tool@v1.0.0",
+			name: "v2tool",
+			version: "v1.0.0",
+		});
+	});
+
+	it("@latest is unpinned, same as parseAtSpec", () => {
+		expect(parseGoSpec("github.com/MadAppGang/tmux-mcp/v2@latest")).toEqual({
+			spec: "github.com/MadAppGang/tmux-mcp/v2@latest",
+			name: "tmux-mcp",
+			version: null,
+		});
+	});
+
+	// Terminal 5.0.0 contract cases (test plan Area 3, C5 and C6). They live
+	// here rather than in their own file because any test file that imports
+	// plugin-setup.js ahead of the mock.module seam above bakes the real
+	// execFile into promisify() and fails the installPluginDeps suites.
+	it("C5: a /v10 suffix is stripped in full, not only its first digit", () => {
+		const { name, version } = parseGoSpec("github.com/x/tool/v10@v10.1.0");
+		expect({ name, version }).toEqual({ name: "tool", version: "v10.1.0" });
+	});
+
+	it("C6: /v1 is never a Go major-version suffix, so it stays the name", () => {
+		const { name, version } = parseGoSpec("github.com/x/tool/v1@v1.0.0");
+		expect({ name, version }).toEqual({ name: "v1", version: "v1.0.0" });
+	});
+
+	it("C6 control: the same shape at /v2 is a suffix and is stripped", () => {
+		const { name, version } = parseGoSpec("github.com/x/tool/v2@v2.0.0");
+		expect({ name, version }).toEqual({ name: "tool", version: "v2.0.0" });
+	});
 });
 
 // ---------------------------------------------------------------------------
@@ -283,9 +367,9 @@ describe("checkMissingDeps — go packages", () => {
 
 describe("extractGoVersion", () => {
 	it("returns the pinned version", () => {
-		expect(
-			extractGoVersion("github.com/MadAppGang/tmux-mcp@v1.6.2"),
-		).toBe("v1.6.2");
+		expect(extractGoVersion("github.com/MadAppGang/tmux-mcp@v1.6.2")).toBe(
+			"v1.6.2",
+		);
 	});
 	it("returns null for @latest (a moving target)", () => {
 		expect(
@@ -295,6 +379,14 @@ describe("extractGoVersion", () => {
 	it("returns null when unpinned", () => {
 		expect(extractGoVersion("github.com/user/tool")).toBeNull();
 	});
+	it("reads the pin behind a /v2 module path", () => {
+		expect(extractGoVersion("github.com/MadAppGang/tmux-mcp/v2@v2.0.0")).toBe(
+			"v2.0.0",
+		);
+	});
+	it("a /v2 module path with no pin is unpinned, not pinned to v2", () => {
+		expect(extractGoVersion("github.com/MadAppGang/tmux-mcp/v2")).toBeNull();
+	});
 });
 
 describe("goDepNeedsInstall — version awareness", () => {
@@ -666,6 +758,16 @@ describe("parseAtSpec", () => {
 		expect(parseAtSpec("tool@latest").version).toBeNull();
 	});
 
+	it("does NOT apply the Go /vN rule — an npm scope may be named v2", () => {
+		// The Go major-version strip lives in parseGoSpec only; folding it in
+		// here would turn this scoped npm package into "@scope".
+		expect(parseAtSpec("@scope/v2@1.0.0")).toEqual({
+			spec: "@scope/v2@1.0.0",
+			name: "v2",
+			version: "1.0.0",
+		});
+	});
+
 	it("treats a bare name as unpinned", () => {
 		expect(parseAtSpec("tool")).toEqual({
 			spec: "tool",

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

@@ -3,11 +3,7 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import fs from "fs-extra";
-import {
-	listProfiles,
-	showProfile,
-	switchProfile,
-} from "../cli/profile.js";
+import { listProfiles, showProfile, switchProfile } from "../cli/profile.js";
 import { activeProfile } from "../services/symlink-manager.js";
 import type { ProfileManifest } from "../types/index.js";
 
@@ -17,9 +13,7 @@ let errs: string[];
 beforeEach(() => {
 	logs = [];
 	errs = [];
-	// biome-ignore lint/suspicious/noExplicitAny: test double
 	console.log = mock((...a: unknown[]) => logs.push(a.join(" "))) as any;
-	// biome-ignore lint/suspicious/noExplicitAny: test double
 	console.error = mock((...a: unknown[]) => errs.push(a.join(" "))) as any;
 });
 afterEach(() => mock.restore());

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

@@ -65,7 +65,9 @@ describe("buildProfileSettings", () => {
 	});
 
 	test("no union given -> no false entries (unchanged legacy shape)", () => {
-		const s = buildProfileSettings(closure({ plugins: { "dev@magus": "latest" } }));
+		const s = buildProfileSettings(
+			closure({ plugins: { "dev@magus": "latest" } }),
+		);
 		expect(s.enabledPlugins).toEqual({ "dev@magus": true });
 	});
 });
@@ -98,14 +100,28 @@ describe("materializeProfile", () => {
 			project,
 		);
 		expect(dir).toBe(profileDir("frontend", project));
-		expect((await fs.readJson(join(dir, "settings.json"))).enabledPlugins["dev@magus"]).toBe(true);
-		expect((await fs.readJson(join(dir, "mcp.json"))).mcpServers.x.command).toBe("y");
+		expect(
+			(await fs.readJson(join(dir, "settings.json"))).enabledPlugins[
+				"dev@magus"
+			],
+		).toBe(true);
+		expect(
+			(await fs.readJson(join(dir, "mcp.json"))).mcpServers.x.command,
+		).toBe("y");
 		expect(await fs.pathExists(join(dir, "skills"))).toBe(true);
 	});
 
 	test("is idempotent (re-materialize overwrites cleanly)", async () => {
-		await materializeProfile("p", closure({ plugins: { "a@m": "latest" } }), project);
-		const dir = await materializeProfile("p", closure({ plugins: { "b@m": "latest" } }), project);
+		await materializeProfile(
+			"p",
+			closure({ plugins: { "a@m": "latest" } }),
+			project,
+		);
+		const dir = await materializeProfile(
+			"p",
+			closure({ plugins: { "b@m": "latest" } }),
+			project,
+		);
 		const settings = await fs.readJson(join(dir, "settings.json"));
 		expect(settings.enabledPlugins).toEqual({ "b@m": true });
 	});
@@ -120,7 +136,10 @@ describe("materializeProfile", () => {
 		const dir = await materializeProfile("p", closure(), project);
 
 		expect(
-			await fs.readFile(join(dir, "skills", "systematic-debugging", "SKILL.md"), "utf8"),
+			await fs.readFile(
+				join(dir, "skills", "systematic-debugging", "SKILL.md"),
+				"utf8",
+			),
 		).toContain("committed project skill");
 	});
 
@@ -157,11 +176,15 @@ describe("materializeProfile", () => {
 			project,
 			union,
 		);
-		expect((await fs.readJson(join(fe, "settings.json"))).enabledPlugins).toEqual({
+		expect(
+			(await fs.readJson(join(fe, "settings.json"))).enabledPlugins,
+		).toEqual({
 			"designer@magus": true,
 			"terminal@magus": false,
 		});
-		expect((await fs.readJson(join(be, "settings.json"))).enabledPlugins).toEqual({
+		expect(
+			(await fs.readJson(join(be, "settings.json"))).enabledPlugins,
+		).toEqual({
 			"designer@magus": false,
 			"terminal@magus": true,
 		});

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

@@ -31,7 +31,10 @@ describe("computeSync (pure)", () => {
 		expect(next.plugins!["dev@magus"]).toBe("2.9.0");
 		// new plugin added as latest
 		expect(next.plugins!["designer@magus"]).toBe("latest");
-		expect(changes).toContainEqual({ kind: "plugin-added", detail: "designer@magus" });
+		expect(changes).toContainEqual({
+			kind: "plugin-added",
+			detail: "designer@magus",
+		});
 	});
 
 	test("removes a plugin that was disabled", () => {
@@ -41,7 +44,10 @@ describe("computeSync (pure)", () => {
 			{ mcpServers: {} },
 		);
 		expect(next.plugins!["terminal@magus"]).toBeUndefined();
-		expect(changes).toContainEqual({ kind: "plugin-removed", detail: "terminal@magus" });
+		expect(changes).toContainEqual({
+			kind: "plugin-removed",
+			detail: "terminal@magus",
+		});
 	});
 
 	test("captures a settings change and an mcp change", () => {
@@ -75,7 +81,14 @@ describe("computeSync (pure)", () => {
 		const withStamp: ProfileManifestEntry = { ...entry, updatedAt: "OLD" };
 		const { entry: changed } = computeSync(
 			withStamp,
-			{ enabledPlugins: { "dev@magus": true, "terminal@magus": true, "new@magus": true }, effortLevel: "high" },
+			{
+				enabledPlugins: {
+					"dev@magus": true,
+					"terminal@magus": true,
+					"new@magus": true,
+				},
+				effortLevel: "high",
+			},
 			{ mcpServers: {} },
 			"2026-07-27T00:00:00.000Z",
 		);
@@ -84,7 +97,10 @@ describe("computeSync (pure)", () => {
 		// Unchanged sync leaves updatedAt alone.
 		const { entry: same } = computeSync(
 			withStamp,
-			{ enabledPlugins: { "dev@magus": true, "terminal@magus": true }, effortLevel: "high" },
+			{
+				enabledPlugins: { "dev@magus": true, "terminal@magus": true },
+				effortLevel: "high",
+			},
 			{ mcpServers: {} },
 			"2026-07-27T00:00:00.000Z",
 		);
@@ -99,7 +115,9 @@ describe("syncProfile (io)", () => {
 		await fs.ensureDir(join(dir, ".claude"));
 		await fs.writeJson(join(dir, ".claude", "profiles.json"), {
 			version: 2,
-			profiles: { frontend: { name: "Frontend", plugins: { "dev@magus": "2.9.0" } } },
+			profiles: {
+				frontend: { name: "Frontend", plugins: { "dev@magus": "2.9.0" } },
+			},
 		});
 	});
 	afterEach(async () => {

package/src/__tests__/registry-version-resolution.test.ts

@@ -14,61 +14,75 @@ import type { InstalledPluginEntry } from "../types/index.js";
  */
 
 const entry = (
-  scope: InstalledPluginEntry["scope"],
-  version: string,
-  projectPath?: string,
+	scope: InstalledPluginEntry["scope"],
+	version: string,
+	projectPath?: string,
 ): InstalledPluginEntry => ({
-  scope,
-  version,
-  projectPath,
-  installPath: `/cache/${version}`,
-  installedAt: "2026-01-01T00:00:00.000Z",
-  lastUpdated: "2026-01-01T00:00:00.000Z",
+	scope,
+	version,
+	projectPath,
+	installPath: `/cache/${version}`,
+	installedAt: "2026-01-01T00:00:00.000Z",
+	lastUpdated: "2026-01-01T00:00:00.000Z",
 });
 
 describe("pickRegistryEntry — scope resolution", () => {
-  test("user scope takes the user entry, ignoring project installs", () => {
-    const entries = [
-      entry("project", "1.0.0", "/proj/a"),
-      entry("user", "2.0.0"),
-      entry("project", "3.0.0", "/proj/b"),
-    ];
-    expect(pickRegistryEntry(entries, "user")?.version).toBe("2.0.0");
-  });
+	test("user scope takes the user entry, ignoring project installs", () => {
+		const entries = [
+			entry("project", "1.0.0", "/proj/a"),
+			entry("user", "2.0.0"),
+			entry("project", "3.0.0", "/proj/b"),
+		];
+		expect(pickRegistryEntry(entries, "user")?.version).toBe("2.0.0");
+	});
 
-  test("project scope prefers the entry pinned to that exact project", () => {
-    const entries = [
-      entry("user", "2.0.0"),
-      entry("project", "1.0.0", "/proj/a"),
-      entry("project", "3.0.0", "/proj/b"),
-    ];
-    expect(pickRegistryEntry(entries, "project", "/proj/b")?.version).toBe("3.0.0");
-  });
+	test("project scope prefers the entry pinned to that exact project", () => {
+		const entries = [
+			entry("user", "2.0.0"),
+			entry("project", "1.0.0", "/proj/a"),
+			entry("project", "3.0.0", "/proj/b"),
+		];
+		expect(pickRegistryEntry(entries, "project", "/proj/b")?.version).toBe(
+			"3.0.0",
+		);
+	});
 
-  test("project scope falls back to the user entry when the project has no install", () => {
-    // This is the statusline case: installed at user scope, absent from project
-    // settings, previously surfaced as "no version" and skipped by update checks.
-    const entries = [entry("user", "2.1.2"), entry("project", "1.0.0", "/proj/other")];
-    expect(pickRegistryEntry(entries, "project", "/proj/mine")?.version).toBe("2.1.2");
-  });
+	test("project scope falls back to the user entry when the project has no install", () => {
+		// This is the statusline case: installed at user scope, absent from project
+		// settings, previously surfaced as "no version" and skipped by update checks.
+		const entries = [
+			entry("user", "2.1.2"),
+			entry("project", "1.0.0", "/proj/other"),
+		];
+		expect(pickRegistryEntry(entries, "project", "/proj/mine")?.version).toBe(
+			"2.1.2",
+		);
+	});
 
-  test("project paths are compared resolved, not as raw strings", () => {
-    const entries = [entry("project", "4.2.0", "/proj/a/../a")];
-    expect(pickRegistryEntry(entries, "project", "/proj/a")?.version).toBe("4.2.0");
-  });
+	test("project paths are compared resolved, not as raw strings", () => {
+		const entries = [entry("project", "4.2.0", "/proj/a/../a")];
+		expect(pickRegistryEntry(entries, "project", "/proj/a")?.version).toBe(
+			"4.2.0",
+		);
+	});
 
-  test("a local-scope entry satisfies a project lookup for the same path", () => {
-    const entries = [entry("local", "5.0.0", "/proj/a"), entry("user", "1.0.0")];
-    expect(pickRegistryEntry(entries, "project", "/proj/a")?.version).toBe("5.0.0");
-  });
+	test("a local-scope entry satisfies a project lookup for the same path", () => {
+		const entries = [
+			entry("local", "5.0.0", "/proj/a"),
+			entry("user", "1.0.0"),
+		];
+		expect(pickRegistryEntry(entries, "project", "/proj/a")?.version).toBe(
+			"5.0.0",
+		);
+	});
 
-  test("no project path and no user entry yields undefined, not a wrong project's version", () => {
-    const entries = [entry("project", "9.9.9", "/proj/somewhere-else")];
-    expect(pickRegistryEntry(entries, "project")).toBeUndefined();
-  });
+	test("no project path and no user entry yields undefined, not a wrong project's version", () => {
+		const entries = [entry("project", "9.9.9", "/proj/somewhere-else")];
+		expect(pickRegistryEntry(entries, "project")).toBeUndefined();
+	});
 
-  test("empty and missing entry lists are handled", () => {
-    expect(pickRegistryEntry([], "user")).toBeUndefined();
-    expect(pickRegistryEntry(undefined, "user")).toBeUndefined();
-  });
+	test("empty and missing entry lists are handled", () => {
+		expect(pickRegistryEntry([], "user")).toBeUndefined();
+		expect(pickRegistryEntry(undefined, "user")).toBeUndefined();
+	});
 });

package/src/__tests__/resolve-executable.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtemp, rm, symlink, writeFile, chmod } from "node:fs/promises";
+import { chmod, mkdtemp, rm, symlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { resolveExecutable } from "../utils/command-utils.js";

package/src/__tests__/resolver.test.ts

@@ -53,7 +53,11 @@ describe("dedupeBins — precedence by order", () => {
 
 	test("a later entry fills a version the winner left unset", () => {
 		const loose: BinRequirement = { name: "tmux", via: "brew" };
-		const pinned: BinRequirement = { name: "tmux", via: "brew", version: "3.4" };
+		const pinned: BinRequirement = {
+			name: "tmux",
+			via: "brew",
+			version: "3.4",
+		};
 		const result = dedupeBins([
 			{ bin: loose, source: "plugin:a" },
 			{ bin: pinned, source: "plugin:b" },
@@ -150,9 +154,9 @@ describe("resolveProfile", () => {
 	});
 
 	test("throws for an unknown profile id", async () => {
-		await expect(
-			resolveProfile(manifestOf({}), "ghost"),
-		).rejects.toThrow('Profile "ghost" not found');
+		await expect(resolveProfile(manifestOf({}), "ghost")).rejects.toThrow(
+			'Profile "ghost" not found',
+		);
 	});
 });
 
@@ -191,12 +195,22 @@ describe("resolveAllProfiles — union", () => {
 
 	test("conflicting explicit pins resolve to the higher semver, order-independent, and are reported", async () => {
 		const mk = (order: "ab" | "ba"): ProfileManifest => {
-			const a: ProfileManifestEntry = { name: "A", plugins: { "dev@magus": "2.9.0" } };
-			const b: ProfileManifestEntry = { name: "B", plugins: { "dev@magus": "2.11.0" } };
+			const a: ProfileManifestEntry = {
+				name: "A",
+				plugins: { "dev@magus": "2.9.0" },
+			};
+			const b: ProfileManifestEntry = {
+				name: "B",
+				plugins: { "dev@magus": "2.11.0" },
+			};
 			return manifestOf(order === "ab" ? { a, b } : { b, a });
 		};
-		const ab = await resolveAllProfiles(mk("ab"), { binResolver: fakeBinResolver({}) });
-		const ba = await resolveAllProfiles(mk("ba"), { binResolver: fakeBinResolver({}) });
+		const ab = await resolveAllProfiles(mk("ab"), {
+			binResolver: fakeBinResolver({}),
+		});
+		const ba = await resolveAllProfiles(mk("ba"), {
+			binResolver: fakeBinResolver({}),
+		});
 
 		// Deterministic: higher pin wins regardless of profile order.
 		expect(ab.plugins["dev@magus"]).toBe("2.11.0");
@@ -211,8 +225,12 @@ describe("resolveAllProfiles — union", () => {
 			a: { name: "A", cliTools: { claudish: "1.2.0" } },
 			b: { name: "B", cliTools: { claudish: "1.5.0" } },
 		});
-		const union = await resolveAllProfiles(manifest, { binResolver: fakeBinResolver({}) });
-		expect(union.bins.find((x) => x.name === "claudish")?.version).toBe("1.5.0");
+		const union = await resolveAllProfiles(manifest, {
+			binResolver: fakeBinResolver({}),
+		});
+		expect(union.bins.find((x) => x.name === "claudish")?.version).toBe(
+			"1.5.0",
+		);
 		expect(union.conflicts?.some((c) => c.includes("claudish"))).toBe(true);
 	});
 });
@@ -255,7 +273,9 @@ describe("marketplaces derived from plugin ids", () => {
 			},
 		});
 		const c = await resolveProfile(manifest, "mixed", noBins);
-		expect(c.marketplaces["magus-marketing"]?.repo).toBe("MadAppGang/magus-marketing");
+		expect(c.marketplaces["magus-marketing"]?.repo).toBe(
+			"MadAppGang/magus-marketing",
+		);
 		expect(c.marketplaces["magus-alpha"]?.repo).toBe("MadAppGang/magus-alpha");
 	});
 
@@ -263,7 +283,9 @@ describe("marketplaces derived from plugin ids", () => {
 		const manifest = manifestOf({
 			pinned: {
 				name: "Pinned",
-				marketplaces: { magus: { source: "github", repo: "MadAppGang/magus-fork" } },
+				marketplaces: {
+					magus: { source: "github", repo: "MadAppGang/magus-fork" },
+				},
 				plugins: { "dev@magus": "latest" },
 			},
 		});
@@ -273,7 +295,10 @@ describe("marketplaces derived from plugin ids", () => {
 
 	test("an unknown marketplace is left for the manifest to declare", async () => {
 		const manifest = manifestOf({
-			third: { name: "Third", plugins: { "thing@someones-marketplace": "latest" } },
+			third: {
+				name: "Third",
+				plugins: { "thing@someones-marketplace": "latest" },
+			},
 		});
 		const c = await resolveProfile(manifest, "third", noBins);
 		expect(c.marketplaces["someones-marketplace"]).toBeUndefined();