claudeup 4.19.0 → 4.23.0

package/src/__tests__/marketplace-refresh.test.ts

@@ -0,0 +1,267 @@
+/**
+ * Tests for refreshRegisteredMarketplaces — the non-destructive marketplace clone
+ * refresh. These use REAL git repositories on purpose: the entire point of the
+ * rework is a real git property — `git pull --ff-only` advances a clone but NEVER
+ * deletes it on failure (unlike `claude plugin marketplace update`, which the repo
+ * deliberately bans; see marketplace-refresh.ts). Only a real pull can prove that,
+ * so the "clone survives a failed pull" cases here are the load-bearing ones.
+ */
+import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+// --- Mock the marketplace registry (the only claudeup dep of the refresher) ---
+let configured: Record<string, { source: { source: string; repo?: string } }>;
+let autoUpdate: Record<string, boolean | undefined>;
+
+mock.module("../services/claude-settings.js", () => ({
+	getConfiguredMarketplaces: async () => configured,
+	getMarketplaceAutoUpdate: async (name: string) => autoUpdate[name],
+	// The refresher resolves clone paths via this helper; point it at our temp
+	// home so no real ~/.claude marketplace is ever touched. (Bun's os.homedir()
+	// ignores runtime $HOME changes, so mocking the helper is the reliable seam.)
+	getGlobalClaudeDir: () => path.join(tmp, ".claude"),
+}));
+
+const { refreshRegisteredMarketplaces, fastForwardCloneIfPresent } =
+	await import("../services/marketplace-refresh.js");
+
+const gh = (repo = "MadAppGang/magus") => ({
+	source: { source: "github", repo },
+});
+
+// git with a deterministic identity, no signing, `main` as default branch — so the
+// suite doesn't depend on the developer's global git config.
+const GIT_CFG = [
+	"-c",
+	"user.email=test@example.com",
+	"-c",
+	"user.name=test",
+	"-c",
+	"commit.gpgsign=false",
+	"-c",
+	"init.defaultBranch=main",
+];
+function git(cwd: string, ...args: string[]): string {
+	return execFileSync("git", [...GIT_CFG, ...args], { cwd, encoding: "utf8" });
+}
+
+let tmp: string;
+let mpRoot: string; // <tmp>/.claude/plugins/marketplaces (via mocked getGlobalClaudeDir)
+let origin: string; // bare origin repo standing in for the GitHub remote
+
+function writePluginJson(dir: string, version: string, pin: string) {
+	const p = path.join(dir, "plugins", "terminal");
+	fs.mkdirSync(p, { recursive: true });
+	fs.writeFileSync(
+		path.join(p, "plugin.json"),
+		JSON.stringify({ version, setup: { go: [pin] } }),
+	);
+}
+function readPin(dir: string): { version: string; pin: string } {
+	const j = JSON.parse(
+		fs.readFileSync(
+			path.join(dir, "plugins", "terminal", "plugin.json"),
+			"utf8",
+		),
+	);
+	return { version: j.version, pin: j.setup.go[0] };
+}
+/** Clone origin into the marketplace dir for `name`, at origin's current HEAD. */
+function installClone(name: string): string {
+	const dir = path.join(mpRoot, name);
+	git(tmp, "clone", origin, dir);
+	return dir;
+}
+/** Advance origin to a v2 (pinned) release, so installed clones become stale. */
+function publishV2() {
+	const pub = path.join(tmp, "pub");
+	git(tmp, "clone", origin, pub);
+	writePluginJson(pub, "4.1.2", "x@v1.6.2");
+	git(pub, "add", "-A");
+	git(pub, "commit", "-m", "v2 pinned");
+	git(pub, "push", "origin", "HEAD:main");
+	fs.rmSync(pub, { recursive: true, force: true });
+}
+
+beforeEach(() => {
+	tmp = fs.mkdtempSync(path.join(os.tmpdir(), "mp-refresh-"));
+	mpRoot = path.join(tmp, ".claude", "plugins", "marketplaces");
+	fs.mkdirSync(mpRoot, { recursive: true });
+
+	// Bare origin seeded at v1 (unpinned).
+	origin = path.join(tmp, "origin.git");
+	const seed = path.join(tmp, "seed");
+	git(tmp, "init", "--bare", origin);
+	git(tmp, "clone", origin, seed);
+	writePluginJson(seed, "4.0.3", "x@latest");
+	git(seed, "add", "-A");
+	git(seed, "commit", "-m", "v1");
+	git(seed, "push", "origin", "HEAD:main");
+	fs.rmSync(seed, { recursive: true, force: true });
+
+	configured = {};
+	autoUpdate = {};
+});
+
+afterEach(() => {
+	fs.rmSync(tmp, { recursive: true, force: true });
+});
+
+describe("refreshRegisteredMarketplaces — the fix (CLAIM #1)", () => {
+	it("fast-forwards a stale clone so a newly pinned setup.go becomes visible", async () => {
+		const dir = installClone("magus");
+		expect(readPin(dir).pin).toBe("x@latest"); // stale on-disk clone
+		publishV2(); // a release lands upstream
+
+		configured = { magus: gh() };
+		const r = await refreshRegisteredMarketplaces();
+
+		expect(r.refreshed).toEqual(["magus"]);
+		expect(r.failed).toEqual([]);
+		// The whole point: the version-aware installer now sees the pin on disk.
+		expect(readPin(dir)).toEqual({ version: "4.1.2", pin: "x@v1.6.2" });
+	});
+
+	it("refreshes when autoUpdate is undefined (default on)", async () => {
+		installClone("magus");
+		publishV2();
+		configured = { magus: gh() };
+		const r = await refreshRegisteredMarketplaces();
+		expect(r.refreshed).toEqual(["magus"]);
+	});
+});
+
+describe("refreshRegisteredMarketplaces — non-destructive on failure (the rework's reason)", () => {
+	it("leaves the clone intact when the remote is unreachable (never deleted)", async () => {
+		const dir = installClone("magus");
+		git(
+			dir,
+			"remote",
+			"set-url",
+			"origin",
+			path.join(tmp, "does-not-exist.git"),
+		);
+		configured = { magus: gh() };
+
+		const r = await refreshRegisteredMarketplaces();
+
+		expect(r.failed).toEqual(["magus"]);
+		expect(fs.existsSync(dir)).toBe(true); // NOT deleted — the destructive mode is gone
+		expect(readPin(dir).pin).toBe("x@latest"); // content untouched
+	});
+
+	it("fails safely when history diverged (ff-only refuses to merge), clone intact", async () => {
+		const dir = installClone("magus");
+		// A local commit the upstream doesn't have → not fast-forwardable.
+		writePluginJson(dir, "4.0.3", "x@local");
+		git(dir, "add", "-A");
+		git(dir, "commit", "-m", "local divergence");
+		publishV2(); // upstream also moves → histories diverge
+
+		configured = { magus: gh() };
+		const r = await refreshRegisteredMarketplaces();
+
+		expect(r.failed).toEqual(["magus"]);
+		expect(fs.existsSync(dir)).toBe(true);
+		expect(readPin(dir).pin).toBe("x@local"); // local work preserved
+	});
+
+	it("refreshes healthy clones even when another fails (parallel, isolated)", async () => {
+		const good = installClone("good");
+		const bad = installClone("bad");
+		git(bad, "remote", "set-url", "origin", path.join(tmp, "nope.git"));
+		publishV2();
+
+		configured = { good: gh(), bad: gh("c/d") };
+		const r = await refreshRegisteredMarketplaces();
+
+		expect(r.refreshed).toEqual(["good"]);
+		expect(r.failed).toEqual(["bad"]);
+		expect(fs.existsSync(bad)).toBe(true);
+		expect(readPin(good).pin).toBe("x@v1.6.2");
+	});
+});
+
+describe("refreshRegisteredMarketplaces — selection & skips", () => {
+	it("skips a clone with uncommitted local changes (never clobbers them)", async () => {
+		const dir = installClone("magus");
+		publishV2();
+		// Uncommitted edit to a tracked file.
+		writePluginJson(dir, "4.0.3", "x@dirty");
+		configured = { magus: gh() };
+
+		const r = await refreshRegisteredMarketplaces();
+
+		expect(r.skipped).toEqual(["magus"]);
+		expect(r.refreshed).toEqual([]);
+		expect(readPin(dir).pin).toBe("x@dirty"); // preserved, not fast-forwarded
+	});
+
+	it("skips a registered marketplace whose clone is not on disk", async () => {
+		configured = { magus: gh() }; // never installed
+		const r = await refreshRegisteredMarketplaces();
+		expect(r.skipped).toEqual(["magus"]);
+		expect(r.failed).toEqual([]);
+	});
+
+	it("skips non-github sources", async () => {
+		configured = { local: { source: { source: "local" } } };
+		const r = await refreshRegisteredMarketplaces();
+		expect(r.refreshed).toEqual([]);
+		expect(r.skipped).toEqual(["local"]);
+	});
+
+	it("skips a marketplace with autoUpdate === false", async () => {
+		installClone("magus");
+		publishV2();
+		configured = { magus: gh() };
+		autoUpdate = { magus: false };
+		const r = await refreshRegisteredMarketplaces();
+		expect(r.refreshed).toEqual([]);
+		expect(r.skipped).toEqual(["magus"]);
+	});
+
+	it("honors the skip set (already handled this run)", async () => {
+		installClone("magus");
+		installClone("other");
+		publishV2();
+		configured = { magus: gh(), other: gh("x/y") };
+
+		const r = await refreshRegisteredMarketplaces(["magus"]);
+
+		expect(r.refreshed).toEqual(["other"]);
+		expect(r.refreshed).not.toContain("magus");
+		expect(r.skipped).not.toContain("magus"); // skip = not touched at all
+	});
+});
+
+describe("fastForwardCloneIfPresent — single-clone helper (shared with claude-cli recovery)", () => {
+	it("returns 'absent' when no clone is on disk (caller then clones via add)", async () => {
+		expect(await fastForwardCloneIfPresent("magus")).toBe("absent");
+	});
+
+	it("returns 'refreshed' and advances a stale clone", async () => {
+		const dir = installClone("magus");
+		publishV2();
+		expect(await fastForwardCloneIfPresent("magus")).toBe("refreshed");
+		expect(readPin(dir).pin).toBe("x@v1.6.2");
+	});
+
+	it("returns 'failed' (never throws, clone intact) when the remote is unreachable", async () => {
+		const dir = installClone("magus");
+		git(dir, "remote", "set-url", "origin", path.join(tmp, "gone.git"));
+		expect(await fastForwardCloneIfPresent("magus")).toBe("failed");
+		expect(fs.existsSync(dir)).toBe(true);
+	});
+
+	it("returns 'skipped' for a dirty clone (never clobbers local edits)", async () => {
+		const dir = installClone("magus");
+		publishV2();
+		writePluginJson(dir, "4.0.3", "x@dirty");
+		expect(await fastForwardCloneIfPresent("magus")).toBe("skipped");
+		expect(readPin(dir).pin).toBe("x@dirty");
+	});
+});

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

@@ -0,0 +1,133 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import fs from "fs-extra";
+import {
+	parsePluginRequires,
+	readPluginRequires,
+} from "../services/plugin-requires.js";
+
+describe("parsePluginRequires", () => {
+	test("parses a valid requires.bin and fills defaults", () => {
+		const requires = parsePluginRequires({
+			name: "terminal",
+			requires: {
+				bin: [
+					{ name: "tmux", via: "brew", formula: "tmux", check: "tmux -V" },
+					{ name: "tmux-mcp", via: "bun", package: "tmux-mcp" },
+				],
+			},
+		});
+		expect(requires.bin).toHaveLength(2);
+		const tmux = requires.bin!.find((b) => b.name === "tmux")!;
+		expect(tmux.via).toBe("brew");
+		expect(tmux.check).toBe("tmux -V");
+		const mcp = requires.bin!.find((b) => b.name === "tmux-mcp")!;
+		// check defaulted from the name
+		expect(mcp.check).toBe("tmux-mcp --version");
+	});
+
+	test("drops entries with no name or an unknown installer", () => {
+		const requires = parsePluginRequires({
+			requires: {
+				bin: [
+					{ via: "bun" }, // no name
+					{ name: "x", via: "cargo" }, // unknown installer
+					{ name: "ok", via: "npm" },
+				],
+			},
+		});
+		expect(requires.bin).toHaveLength(1);
+		expect(requires.bin![0]!.name).toBe("ok");
+	});
+
+	test("no requires / non-array bin → empty object", () => {
+		expect(parsePluginRequires({ name: "x" })).toEqual({});
+		expect(parsePluginRequires({ requires: {} })).toEqual({});
+		expect(parsePluginRequires({ requires: { bin: "nope" } })).toEqual({});
+		expect(parsePluginRequires(null)).toEqual({});
+	});
+});
+
+describe("parsePluginRequires — setup block (the established convention)", () => {
+	test("terminal's setup: go module + required system tool", () => {
+		// The real plugins/terminal/plugin.json shape.
+		const r = parsePluginRequires({
+			name: "terminal",
+			setup: {
+				go: ["github.com/MadAppGang/tmux-mcp@latest"],
+				required: ["tmux"],
+			},
+		});
+		const mcp = r.bin!.find((b) => b.name === "tmux-mcp")!;
+		expect(mcp.via).toBe("go");
+		expect(mcp.module).toBe("github.com/MadAppGang/tmux-mcp");
+		expect(mcp.version).toBe("latest");
+		const tmux = r.bin!.find((b) => b.name === "tmux")!;
+		expect(tmux.via).toBe("brew");
+		expect(tmux.formula).toBe("tmux");
+	});
+
+	test("browser-use's setup: pip packages", () => {
+		const r = parsePluginRequires({
+			name: "browser-use",
+			setup: { pip: ["browser-use", "mcp"] },
+		});
+		expect(r.bin!.map((b) => b.name).sort()).toEqual(["browser-use", "mcp"]);
+		expect(r.bin!.every((b) => b.via === "pip")).toBe(true);
+	});
+
+	test("bun/npm specs split name@version", () => {
+		const r = parsePluginRequires({
+			setup: { bun: ["claudish@1.2.0"], npm: ["@scope/tool@3.0.0"] },
+		});
+		const claudish = r.bin!.find((b) => b.name === "claudish")!;
+		expect(claudish.version).toBe("1.2.0");
+		const scoped = r.bin!.find((b) => b.name === "tool")!;
+		expect(scoped.package).toBe("@scope/tool");
+		expect(scoped.version).toBe("3.0.0");
+	});
+
+	test("explicit requires.bin overrides a setup entry of the same name", () => {
+		const r = parsePluginRequires({
+			setup: { required: ["tmux"] }, // → brew
+			requires: { bin: [{ name: "tmux", via: "go", module: "example.com/tmux" }] },
+		});
+		const tmux = r.bin!.find((b) => b.name === "tmux")!;
+		expect(tmux.via).toBe("go"); // requires.bin won
+	});
+});
+
+describe("readPluginRequires", () => {
+	let dir: string;
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "plugreq-"));
+	});
+	afterEach(async () => {
+		await rm(dir, { recursive: true, force: true });
+	});
+
+	test("reads plugin.json at the plugin root", async () => {
+		await fs.writeJson(join(dir, "plugin.json"), {
+			name: "p",
+			requires: { bin: [{ name: "tmux", via: "brew" }] },
+		});
+		const r = await readPluginRequires(dir);
+		expect(r.bin?.[0]?.name).toBe("tmux");
+	});
+
+	test("falls back to .claude-plugin/plugin.json", async () => {
+		await fs.ensureDir(join(dir, ".claude-plugin"));
+		await fs.writeJson(join(dir, ".claude-plugin", "plugin.json"), {
+			name: "p",
+			requires: { bin: [{ name: "mnemex", via: "bun" }] },
+		});
+		const r = await readPluginRequires(dir);
+		expect(r.bin?.[0]?.name).toBe("mnemex");
+	});
+
+	test("missing manifest → empty", async () => {
+		expect(await readPluginRequires(dir)).toEqual({});
+	});
+});

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

@@ -7,6 +7,11 @@
  */
 
 import { describe, it, expect, mock, beforeEach } from "bun:test";
+// 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
@@ -21,6 +26,7 @@ let execResults: Map<
 
 // Mock command-utils BEFORE importing plugin-setup
 mock.module("../utils/command-utils.js", () => ({
+	...actualCommandUtils,
 	which: async (cmd: string) => {
 		return availableBinaries.has(cmd) ? `/usr/bin/${cmd}` : null;
 	},
@@ -28,6 +34,7 @@ mock.module("../utils/command-utils.js", () => ({
 
 // Mock child_process execFile — promisify wraps this callback-based API
 mock.module("node:child_process", () => ({
+	...actualChildProcess,
 	execFile: (
 		cmd: string,
 		args: string[],

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

@@ -0,0 +1,116 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+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 { activeProfile } from "../services/symlink-manager.js";
+import type { ProfileManifest } from "../types/index.js";
+
+let logs: string[];
+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());
+
+async function setupProject(
+	manifest: ProfileManifest,
+	materialize: string[] = [],
+): Promise<string> {
+	const dir = await mkdtemp(join(tmpdir(), "profcmd-"));
+	await fs.ensureDir(join(dir, ".claude"));
+	await fs.writeJson(join(dir, ".claude", "profiles.json"), manifest);
+	for (const name of materialize) {
+		const pd = join(dir, ".claude", "_profiles", name);
+		await fs.ensureDir(pd);
+		await fs.writeJson(join(pd, "settings.json"), { which: name });
+		await fs.writeJson(join(pd, "mcp.json"), { mcpServers: {} });
+	}
+	return dir;
+}
+
+const twoProfiles: ProfileManifest = {
+	version: 2,
+	profiles: {
+		frontend: { name: "Frontend", plugins: { "dev@magus": "latest" } },
+		backend: { name: "Backend", plugins: { "dev@magus": "2.9.0" } },
+	},
+};
+
+describe("profile list", () => {
+	let dir: string;
+	afterEach(async () => {
+		if (dir) await rm(dir, { recursive: true, force: true });
+	});
+
+	test("lists profiles, marks (not installed) and the active one", async () => {
+		dir = await setupProject(twoProfiles, ["frontend"]);
+		await switchProfile("frontend", dir); // activate
+		logs = [];
+		const code = await listProfiles(dir);
+		expect(code).toBe(0);
+		const out = logs.join("\n");
+		expect(out).toContain("frontend");
+		expect(out).toContain("Backend");
+		expect(out).toContain("(not installed)"); // backend isn't materialized
+		expect(out).toContain("Active: frontend");
+	});
+});
+
+describe("profile show", () => {
+	let dir: string;
+	afterEach(async () => {
+		if (dir) await rm(dir, { recursive: true, force: true });
+	});
+
+	test("prints a resolved closure summary", async () => {
+		dir = await setupProject(twoProfiles);
+		const code = await showProfile("backend", dir);
+		expect(code).toBe(0);
+		expect(logs.join("\n")).toContain("dev@magus@2.9.0");
+	});
+
+	test("unknown profile → exit 1", async () => {
+		dir = await setupProject(twoProfiles);
+		expect(await showProfile("ghost", dir)).toBe(1);
+	});
+});
+
+describe("profile switch", () => {
+	let dir: string;
+	afterEach(async () => {
+		if (dir) await rm(dir, { recursive: true, force: true });
+	});
+
+	test("switches when materialized and records the active profile", async () => {
+		dir = await setupProject(twoProfiles, ["frontend", "backend"]);
+		expect(await switchProfile("backend", dir)).toBe(0);
+		expect(await activeProfile(dir)).toBe("backend");
+		// gitignore got the _profiles entry
+		expect(await fs.readFile(join(dir, ".gitignore"), "utf8")).toContain(
+			".claude/_profiles/",
+		);
+	});
+
+	test("refuses to switch to a profile that isn't installed", async () => {
+		dir = await setupProject(twoProfiles, ["frontend"]);
+		expect(await switchProfile("backend", dir)).toBe(1);
+		expect(errs.join("\n")).toContain("claudeup install backend");
+	});
+
+	test("unknown profile → exit 1", async () => {
+		dir = await setupProject(twoProfiles);
+		expect(await switchProfile("ghost", dir)).toBe(1);
+	});
+});

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

@@ -0,0 +1,82 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import fs from "fs-extra";
+import {
+	buildProfileMcp,
+	buildProfileSettings,
+	materializeProfile,
+} from "../services/profile-materializer.js";
+import { profileDir } from "../services/symlink-manager.js";
+import type { ResolvedClosure } from "../types/index.js";
+
+function closure(overrides: Partial<ResolvedClosure> = {}): ResolvedClosure {
+	return {
+		marketplaces: {},
+		plugins: {},
+		mcpServers: {},
+		bins: [],
+		skills: [],
+		settings: {},
+		env: { required: [], optional: [] },
+		...overrides,
+	};
+}
+
+describe("buildProfileSettings", () => {
+	test("enables every resolved plugin and merges declared settings", () => {
+		const s = buildProfileSettings(
+			closure({
+				plugins: { "dev@magus": "2.9.0", "terminal@magus": "latest" },
+				settings: { enableAllProjectMcpServers: true },
+			}),
+		);
+		expect(s.enabledPlugins).toEqual({
+			"dev@magus": true,
+			"terminal@magus": true,
+		});
+		expect(s.enableAllProjectMcpServers).toBe(true);
+	});
+});
+
+describe("buildProfileMcp", () => {
+	test("wraps the closure's mcpServers", () => {
+		const m = buildProfileMcp(
+			closure({ mcpServers: { "chrome-devtools": { command: "npx" } } }),
+		);
+		expect(m.mcpServers["chrome-devtools"]).toEqual({ command: "npx" });
+	});
+});
+
+describe("materializeProfile", () => {
+	let project: string;
+	beforeEach(async () => {
+		project = await mkdtemp(join(tmpdir(), "materialize-"));
+	});
+	afterEach(async () => {
+		await rm(project, { recursive: true, force: true });
+	});
+
+	test("writes settings.json, mcp.json, and an empty skills/ dir", async () => {
+		const dir = await materializeProfile(
+			"frontend",
+			closure({
+				plugins: { "dev@magus": "latest" },
+				mcpServers: { x: { command: "y" } },
+			}),
+			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.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);
+		const settings = await fs.readJson(join(dir, "settings.json"));
+		expect(settings.enabledPlugins).toEqual({ "b@m": true });
+	});
+});