magus-cli 0.0.0-placeholder → 7.1.0

package/src/__tests__/hook-import-policy.test.ts

@@ -0,0 +1,90 @@
+/**
+ * The hook path must never load the TUI.
+ *
+ * Claude Code runs `magus hook …` on every matching tool call, so anything
+ * the entry point imports is paid for on every tool call — and `@opentui/*`
+ * plus the `src/ui/` tree is the expensive half of this program. Two guards,
+ * because they fail differently:
+ *
+ *  - H-1 BUNDLES `src/cli/hook.ts` and inspects the output. A transitive import
+ *    added three modules deep still shows up here.
+ *  - H-2 reads `src/main.tsx` as text. Bundling cannot see this one: the TUI is
+ *    reachable from main.tsx by design, just only through a dynamic import that
+ *    the hook branch returns before. A *static* import would re-couple them
+ *    while every runtime test still passed, so the source is what is pinned —
+ *    the same technique dual-write-prevention.test.ts uses.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+const HOOK_ENTRY = path.join(import.meta.dir, "..", "cli", "hook.ts");
+const MAIN_TSX = path.join(import.meta.dir, "..", "main.tsx");
+
+/** Drop `//` line comments and `/* *\/` blocks so the guards match code only. */
+function stripComments(source: string): string {
+	return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+}
+
+describe("hook entry point", () => {
+	test("H-1: bundling src/cli/hook.ts pulls in neither @opentui nor src/ui", async () => {
+		const build = await Bun.build({
+			entrypoints: [HOOK_ENTRY],
+			target: "bun",
+		});
+
+		expect(build.logs).toEqual([]);
+		expect(build.success).toBe(true);
+		expect(build.outputs.length).toBeGreaterThan(0);
+
+		const bundle = (
+			await Promise.all(build.outputs.map((output) => output.text()))
+		).join("\n");
+
+		expect(bundle).not.toContain("@opentui");
+		expect(bundle).not.toContain("/ui/");
+	});
+});
+
+describe("main.tsx import policy", () => {
+	const source = stripComments(readFileSync(MAIN_TSX, "utf-8"));
+
+	/**
+	 * Every STATIC import/export specifier. `from "…"` only, which is exactly
+	 * what a dynamic `import("…")` does not have — so the dynamic loads main.tsx
+	 * relies on are invisible here, and that is the point.
+	 */
+	const staticSpecifiers = [
+		...source.matchAll(/\bfrom\s+["']([^"']+)["']/g),
+	].map((match) => match[1] as string);
+
+	test("H-2: no static import of @opentui/*", () => {
+		expect(staticSpecifiers.filter((s) => s.startsWith("@opentui"))).toEqual(
+			[],
+		);
+	});
+
+	test("H-2b: no static import of ./ui/*", () => {
+		expect(staticSpecifiers.filter((s) => s.startsWith("./ui/"))).toEqual([]);
+	});
+
+	test("H-2c: the guard sees the specifiers it is meant to see", () => {
+		// Negative control: a regex that matched nothing would pass H-2 and H-2b
+		// forever. main.tsx does still carry static imports — just harmless ones.
+		expect(staticSpecifiers.length).toBeGreaterThan(0);
+		expect(staticSpecifiers).toContain("./services/dotenv.js");
+	});
+
+	test("H-3: the hook branch is dispatched before the .env load", () => {
+		// Ordering, at source level, for the same reason theme-env.test.ts pins
+		// the snapshot: a hook must never open a project .env — it may be a
+		// symlink to a FIFO, and reading one blocks on every tool call.
+		const hookAt = source.indexOf('await import("./cli/hook.js")');
+		const dotenvAt = source.indexOf("loadProjectDotenv(");
+
+		expect(hookAt).toBeGreaterThan(-1);
+		expect(dotenvAt).toBeGreaterThan(-1);
+		expect(hookAt).toBeLessThan(dotenvAt);
+	});
+});

package/src/__tests__/hook-process.test.ts

@@ -0,0 +1,256 @@
+/**
+ * The hook as Claude Code actually runs it: a spawned process, a JSON payload on stdin, and
+ * whatever lands on stdout.
+ *
+ * `models-core.test.ts` covers the decision logic in-process. This file covers the things only
+ * a real spawn can show — that the binary starts, that it reads stdin, that it finds a config
+ * by walking up from the payload's cwd, and above all that EVERY failure mode is silent and
+ * exit 0. Claude Code spawns this on every Agent call in every session on the machine, so a
+ * hook that throws, hangs or exits non-zero would break delegation everywhere at once.
+ *
+ * The negative control is the point of the file: without a config, the same invocation must
+ * produce nothing at all. A test that only checks the happy path cannot tell a working hook
+ * from one that injects unconditionally.
+ */
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+	mkdirSync,
+	mkdtempSync,
+	rmSync,
+	symlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const MAIN = join(dirname(fileURLToPath(import.meta.url)), "..", "main.tsx");
+
+let dir: string;
+
+interface RunResult {
+	stdout: string;
+	stderr: string;
+	exitCode: number;
+	ms: number;
+}
+
+/** Spawn the hook exactly as a settings.json `command` entry would. */
+async function runHook(
+	payload: unknown,
+	opts: { cwd?: string; args?: string[] } = {},
+): Promise<RunResult> {
+	const started = Date.now();
+	const proc = Bun.spawn(
+		["bun", "--no-env-file", MAIN, "hook", ...(opts.args ?? ["agent-model"])],
+		{
+			cwd: opts.cwd ?? dir,
+			stdin: new TextEncoder().encode(
+				typeof payload === "string" ? payload : JSON.stringify(payload),
+			),
+			stdout: "pipe",
+			stderr: "pipe",
+		},
+	);
+	const [stdout, stderr, exitCode] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+		proc.exited,
+	]);
+	return { stdout, stderr, exitCode, ms: Date.now() - started };
+}
+
+const CONFIG = {
+	version: 1,
+	preset: "test",
+	main: { model: "opus", effort: "medium" },
+	grades: {
+		smart: { model: "fable", effort: "xhigh" },
+		normal: { model: "opus", effort: "medium" },
+		cheap: { model: "sonnet", effort: "low" },
+	},
+	agents: {
+		"dev:architect": "smart",
+		Explore: "cheap",
+		"dev:researcher": { model: "inherit" },
+	},
+	fallback: "normal",
+};
+
+function writeConfig(at: string, config: unknown = CONFIG): void {
+	mkdirSync(join(at, ".claude"), { recursive: true });
+	writeFileSync(
+		join(at, ".claude", "models.json"),
+		JSON.stringify(config, null, 2),
+	);
+}
+
+const agentPayload = (input: Record<string, unknown> = {}, cwd = dir) => ({
+	hook_event_name: "PreToolUse",
+	tool_name: "Agent",
+	cwd,
+	tool_input: { subagent_type: "dev:architect", prompt: "go", ...input },
+});
+
+beforeEach(() => {
+	dir = mkdtempSync(join(tmpdir(), "magus-hook-"));
+});
+afterEach(() => {
+	rmSync(dir, { recursive: true, force: true });
+});
+
+describe("magus hook agent-model", () => {
+	test("injects the routed model, and emits hookEventName", async () => {
+		writeConfig(dir);
+		const r = await runHook(agentPayload());
+		expect(r.exitCode).toBe(0);
+		expect(r.stderr).toBe("");
+		expect(JSON.parse(r.stdout)).toEqual({
+			hookSpecificOutput: {
+				hookEventName: "PreToolUse",
+				updatedInput: {
+					subagent_type: "dev:architect",
+					prompt: "go",
+					model: "fable",
+				},
+			},
+		});
+	});
+
+	test("NEGATIVE CONTROL: no config means no output at all", async () => {
+		// Without this the happy path above cannot distinguish routing from injecting always.
+		const r = await runHook(agentPayload());
+		expect(r.exitCode).toBe(0);
+		expect(r.stdout).toBe("");
+		expect(r.stderr).toBe("");
+	});
+
+	test("walks up to a config in a parent directory", async () => {
+		writeConfig(dir);
+		const nested = join(dir, "packages", "api", "src");
+		mkdirSync(nested, { recursive: true });
+		const r = await runHook(agentPayload({}, nested));
+		expect(JSON.parse(r.stdout).hookSpecificOutput.updatedInput.model).toBe(
+			"fable",
+		);
+	});
+
+	test("uses the payload's cwd, not the process's", async () => {
+		// A session's directory is not where this process was started, and the payload is the
+		// only thing that knows the difference.
+		const elsewhere = mkdtempSync(join(tmpdir(), "magus-hook-other-"));
+		try {
+			writeConfig(elsewhere);
+			const r = await runHook(agentPayload({}, elsewhere), { cwd: dir });
+			expect(JSON.parse(r.stdout).hookSpecificOutput.updatedInput.model).toBe(
+				"fable",
+			);
+		} finally {
+			rmSync(elsewhere, { recursive: true, force: true });
+		}
+	});
+
+	test("respects a model the caller already set", async () => {
+		writeConfig(dir);
+		const r = await runHook(agentPayload({ model: "haiku" }));
+		expect(r.stdout).toBe("");
+	});
+
+	test("`inherit` leaves the call alone", async () => {
+		writeConfig(dir);
+		const r = await runHook(agentPayload({ subagent_type: "dev:researcher" }));
+		expect(r.stdout).toBe("");
+	});
+
+	test("an unknown agent takes the fallback grade", async () => {
+		writeConfig(dir);
+		const r = await runHook(agentPayload({ subagent_type: "brand-new:agent" }));
+		expect(JSON.parse(r.stdout).hookSpecificOutput.updatedInput.model).toBe(
+			"opus",
+		);
+	});
+
+	test("ignores a tool that is not Agent", async () => {
+		writeConfig(dir);
+		const r = await runHook({
+			tool_name: "Bash",
+			cwd: dir,
+			tool_input: { command: "ls" },
+		});
+		expect(r.stdout).toBe("");
+		expect(r.exitCode).toBe(0);
+	});
+
+	describe("fails open", () => {
+		test("garbage on stdin", async () => {
+			writeConfig(dir);
+			const r = await runHook("not json at all {{{");
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+
+		test("empty stdin", async () => {
+			writeConfig(dir);
+			const r = await runHook("");
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+
+		test("an unparseable config", async () => {
+			mkdirSync(join(dir, ".claude"), { recursive: true });
+			writeFileSync(join(dir, ".claude", "models.json"), "{ broken");
+			const r = await runHook(agentPayload());
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+
+		test("an INVALID config routes nothing rather than injecting a bad model", async () => {
+			// Measured (AMR-1 bogus-model): a non-alias refuses the spawn outright, so injecting
+			// one would break every delegation for everyone who pulled the config.
+			writeConfig(dir, {
+				...CONFIG,
+				grades: { ...CONFIG.grades, smart: { model: "kimi-k2" } },
+			});
+			const r = await runHook(agentPayload());
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+
+		test("a config from a future version", async () => {
+			writeConfig(dir, { ...CONFIG, version: 99 });
+			const r = await runHook(agentPayload());
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+
+		test("an unrecognised hook name", async () => {
+			writeConfig(dir);
+			const r = await runHook(agentPayload(), { args: ["something-else"] });
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+	});
+
+	test("a .env symlinked to a FIFO does not hang the hook", async () => {
+		// In this repo `.env` is often a symlink to a 1Password FIFO. Bun autoloads the cwd's
+		// .env before user code unless told not to, and reading a FIFO with no writer blocks
+		// forever — which would look exactly like Claude Code freezing on every Agent call.
+		writeConfig(dir);
+		const fifo = join(dir, "fifo-target");
+		Bun.spawnSync(["mkfifo", fifo]);
+		symlinkSync(fifo, join(dir, ".env"));
+		const r = await runHook(agentPayload());
+		expect(r.exitCode).toBe(0);
+		expect(JSON.parse(r.stdout).hookSpecificOutput.updatedInput.model).toBe(
+			"fable",
+		);
+	});
+
+	test("stays well inside a hook timeout", async () => {
+		writeConfig(dir);
+		const r = await runHook(agentPayload());
+		// Registered with timeout: 5s. From source (not the compiled binary) this measures
+		// ~0.02-0.3s; a regression that pulls the TUI back onto this path would blow past it.
+		expect(r.ms).toBeLessThan(3000);
+	});
+});

package/src/__tests__/hook-registration.test.ts

@@ -0,0 +1,224 @@
+/**
+ * hook-registration — putting `magus hook agent-model` into user settings.
+ *
+ * The pure functions are tested against plain objects; the writer is tested
+ * against a temp `CLAUDE_CONFIG_DIR`, never the operator's real one.
+ */
+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 {
+	AGENT_MODEL_HOOK_COMMAND,
+	ensureHookRegistered,
+	isAgentModelHookRegistered,
+	isHookRegistered,
+	registerAgentModelHook,
+	removeHookRegistration,
+} from "../services/hook-registration.js";
+
+const ENTRY = {
+	type: "command",
+	command: AGENT_MODEL_HOOK_COMMAND,
+	timeout: 5,
+};
+
+describe("ensureHookRegistered", () => {
+	test("writes the measured shape: a PreToolUse block matching Agent", () => {
+		const { settings, changed } = ensureHookRegistered({});
+		expect(changed).toBe(true);
+		expect(settings).toEqual({
+			hooks: { PreToolUse: [{ matcher: "Agent", hooks: [ENTRY] }] },
+		});
+	});
+
+	// Identity is the command string, so re-running magus never accumulates
+	// duplicate registrations.
+	test("is idempotent", () => {
+		const first = ensureHookRegistered({});
+		const second = ensureHookRegistered(first.settings);
+		expect(second.changed).toBe(false);
+		expect(second.settings).toBe(first.settings);
+	});
+
+	// A second block with the same matcher works, but makes the user's settings
+	// progressively less readable and looks like a bug when they open it.
+	test("appends into an existing Agent block instead of adding a second one", () => {
+		const existing = {
+			hooks: {
+				PreToolUse: [
+					{
+						matcher: "Agent",
+						hooks: [{ type: "command", command: "my-own-audit-hook" }],
+					},
+				],
+			},
+		};
+		const { settings } = ensureHookRegistered(existing);
+		const blocks = (settings.hooks as any).PreToolUse;
+		expect(blocks).toHaveLength(1);
+		expect(blocks[0].hooks).toEqual([
+			{ type: "command", command: "my-own-audit-hook" },
+			ENTRY,
+		]);
+	});
+
+	test("leaves other tools' hooks and other settings untouched", () => {
+		const existing = {
+			model: "opus",
+			hooks: {
+				PreToolUse: [
+					{ matcher: "Bash", hooks: [{ type: "command", command: "guard" }] },
+				],
+				Stop: [{ hooks: [{ type: "command", command: "chime" }] }],
+			},
+		};
+		const { settings } = ensureHookRegistered(existing);
+		expect(settings.model).toBe("opus");
+		expect((settings.hooks as any).Stop).toEqual(existing.hooks.Stop);
+		expect((settings.hooks as any).PreToolUse[0].matcher).toBe("Bash");
+		expect((settings.hooks as any).PreToolUse[1]).toEqual({
+			matcher: "Agent",
+			hooks: [ENTRY],
+		});
+	});
+
+	test("does not mutate the object it was given", () => {
+		const original = { hooks: { PreToolUse: [] } };
+		ensureHookRegistered(original);
+		expect(original).toEqual({ hooks: { PreToolUse: [] } });
+	});
+
+	// Never an absolute path: `magus upgrade` replaces the binary, and on npm
+	// the path carries a version directory. A recorded absolute path is dead
+	// after the next upgrade, and a hook that cannot start routes nothing with
+	// no error anyone sees.
+	test("registers the bare command, not a path", () => {
+		const { settings } = ensureHookRegistered({});
+		const command = (settings.hooks as any).PreToolUse[0].hooks[0].command;
+		expect(command).toBe("magus hook agent-model");
+		expect(command.includes("/")).toBe(false);
+	});
+});
+
+describe("isHookRegistered", () => {
+	test("false for every shape that is not a hooks array", () => {
+		expect(isHookRegistered({})).toBe(false);
+		expect(isHookRegistered({ hooks: "nope" })).toBe(false);
+		expect(isHookRegistered({ hooks: { PreToolUse: "nope" } })).toBe(false);
+		expect(isHookRegistered({ hooks: { PreToolUse: [{}] } })).toBe(false);
+	});
+
+	test("finds the command wherever it sits", () => {
+		expect(
+			isHookRegistered({
+				hooks: {
+					PreToolUse: [
+						{ matcher: "Bash", hooks: [{ command: "x" }] },
+						{ matcher: "Agent", hooks: [{ command: "y" }, ENTRY] },
+					],
+				},
+			}),
+		).toBe(true);
+	});
+});
+
+describe("removeHookRegistration", () => {
+	test("round-trips: register then remove leaves no trace", () => {
+		const { settings } = ensureHookRegistered({ model: "opus" });
+		const removed = removeHookRegistration(settings);
+		expect(removed.changed).toBe(true);
+		expect(removed.settings).toEqual({ model: "opus" });
+	});
+
+	test("keeps other commands in a shared Agent block", () => {
+		const { settings } = ensureHookRegistered({
+			hooks: {
+				PreToolUse: [{ matcher: "Agent", hooks: [{ command: "mine" }] }],
+			},
+		});
+		const removed = removeHookRegistration(settings);
+		expect((removed.settings.hooks as any).PreToolUse).toEqual([
+			{ matcher: "Agent", hooks: [{ command: "mine" }] },
+		]);
+	});
+
+	test("no-op when it was never registered", () => {
+		const before = { hooks: { Stop: [] } };
+		const removed = removeHookRegistration(before);
+		expect(removed.changed).toBe(false);
+		expect(removed.settings).toBe(before);
+	});
+});
+
+describe("registerAgentModelHook", () => {
+	let configDir: string;
+	let previous: string | undefined;
+
+	beforeEach(async () => {
+		configDir = await mkdtemp(join(tmpdir(), "hookreg-"));
+		previous = process.env.CLAUDE_CONFIG_DIR;
+		process.env.CLAUDE_CONFIG_DIR = configDir;
+	});
+	afterEach(async () => {
+		// biome-ignore lint/performance/noDelete: absence is the intent, not a shortcut
+		if (previous === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+		else process.env.CLAUDE_CONFIG_DIR = previous;
+		await rm(configDir, { recursive: true, force: true });
+	});
+
+	const settingsPath = () => join(configDir, "settings.json");
+
+	test("honours CLAUDE_CONFIG_DIR and reports registered, then already", async () => {
+		expect(await registerAgentModelHook()).toBe("registered");
+		expect(await fs.pathExists(settingsPath())).toBe(true);
+		expect(await isAgentModelHookRegistered()).toBe(true);
+		expect(await registerAgentModelHook()).toBe("already");
+	});
+
+	test("an explicit configDir overrides the environment", async () => {
+		const other = await mkdtemp(join(tmpdir(), "hookreg-other-"));
+		try {
+			await registerAgentModelHook({ configDir: other });
+			expect(await fs.pathExists(join(other, "settings.json"))).toBe(true);
+			expect(await fs.pathExists(settingsPath())).toBe(false);
+		} finally {
+			await rm(other, { recursive: true, force: true });
+		}
+	});
+
+	test("preserves every other key in the user's settings", async () => {
+		await fs.outputJson(settingsPath(), {
+			model: "sonnet",
+			enabledPlugins: { "dev@magus": true },
+			hooks: { SessionStart: [{ hooks: [{ command: "hello" }] }] },
+		});
+
+		await registerAgentModelHook();
+
+		const after = await fs.readJson(settingsPath());
+		expect(after.model).toBe("sonnet");
+		expect(after.enabledPlugins).toEqual({ "dev@magus": true });
+		expect(after.hooks.SessionStart).toEqual([
+			{ hooks: [{ command: "hello" }] },
+		]);
+		expect(after.hooks.PreToolUse[0].matcher).toBe("Agent");
+	});
+
+	// The reason this does NOT use readGlobalSettings/writeGlobalSettings: those
+	// swallow a parse error and return {}, so a settings file a human is
+	// mid-edit in would come back holding one hook and nothing else.
+	test("throws on unparseable user settings and leaves the file alone", async () => {
+		await fs.outputFile(settingsPath(), '{ "model": "opus", ');
+
+		await expect(registerAgentModelHook()).rejects.toThrow(/not valid JSON/);
+
+		expect(await fs.readFile(settingsPath(), "utf8")).toBe(
+			'{ "model": "opus", ',
+		);
+		// And the read-side reports "not registered" rather than throwing, so
+		// doctor/status can still say something useful about a broken file.
+		expect(await isAgentModelHookRegistered()).toBe(false);
+	});
+});

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

@@ -0,0 +1,81 @@
+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 { runInstallCommand } from "../cli/install.js";
+
+// Integration coverage for runInstallCommand's VALIDATION wiring — the paths
+// that return before the closure is resolved. We deliberately don't exercise
+// --check / the drift guard here: those resolve the closure, which reaches
+// claude-settings/plugin-manager — modules other test files replace globally
+// via bun's mock.module (not restorable across files in bun 1.3.10). The
+// --check and drift LOGIC is covered by pure-function tests instead
+// (install-plan.test.ts computeVersionDrift, profile-sync.test.ts computeSync).
+//
+// runInstallCommand takes an explicit projectPath so no cwd juggling is needed.
+// Console is captured via explicit save/restore.
+
+let logs: string[];
+let errs: string[];
+let origLog: any;
+let origErr: any;
+beforeEach(() => {
+	logs = [];
+	errs = [];
+	origLog = console.log;
+	origErr = console.error;
+	console.log = (...a: unknown[]) => {
+		logs.push(a.join(" "));
+	};
+	console.error = (...a: unknown[]) => {
+		errs.push(a.join(" "));
+	};
+});
+afterEach(() => {
+	console.log = origLog;
+	console.error = origErr;
+});
+
+async function project(manifest: object): Promise<string> {
+	const dir = await mkdtemp(join(tmpdir(), "installcmd-"));
+	await fs.ensureDir(join(dir, ".claude"));
+	await fs.writeJson(join(dir, ".claude", "profiles.json"), manifest);
+	return dir;
+}
+
+describe("runInstallCommand — early-return paths", () => {
+	let dir: string | undefined;
+	afterEach(async () => {
+		if (dir) await rm(dir, { recursive: true, force: true });
+		dir = undefined;
+	});
+
+	// Exit code is the contract these assert. (Console-content assertions are
+	// unreliable under bun's cross-file test interleaving, so we don't make
+	// them here — the messages themselves are covered by the validator's own
+	// unit tests in manifest.test.ts.)
+
+	test("invalid manifest (plugin id without @) → exit 1", async () => {
+		dir = await project({
+			version: 2,
+			profiles: { p: { name: "P", plugins: { dev: "1.0.0" } } },
+		});
+		expect(await runInstallCommand(["--check"], dir)).toBe(1);
+	});
+
+	test("unknown profile → exit 1", async () => {
+		dir = await project({
+			version: 2,
+			profiles: {
+				frontend: { name: "Frontend", plugins: { "dev@magus": "latest" } },
+			},
+		});
+		expect(await runInstallCommand(["ghost", "--check"], dir)).toBe(1);
+	});
+
+	test("empty manifest (no profiles) → exit 1", async () => {
+		dir = await project({ version: 2, profiles: {} });
+		expect(await runInstallCommand(["--check"], dir)).toBe(1);
+	});
+});