claudeup 6.3.2 → 6.4.0

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

@@ -0,0 +1,224 @@
+/**
+ * hook-registration — putting `claudeup 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 claudeup 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: `claudeup 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("claudeup 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__/manifest.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import fs from "fs-extra";
 import {
 	emptyManifest,
+	mergeManifestSettings,
 	migrateToV2,
 	readManifest,
 	validateManifest,
@@ -106,6 +107,139 @@ describe("validateManifest", () => {
 			true,
 		);
 	});
+
+	// Model routing is the one field whose bad value does not degrade: MEASURED
+	// (benches/agent-model-routing `bogus-model`, 5/5), a model the Agent tool
+	// does not accept refuses the spawn outright, so every subagent dispatch
+	// fails for everyone who pulled the manifest. This is the gate.
+	test("a hand-edited models block is validated, path-prefixed by profile", () => {
+		const errors = validateManifest({
+			version: 2,
+			profiles: {
+				p: {
+					name: "P",
+					models: {
+						version: 1,
+						preset: "hand",
+						main: { model: "opus" },
+						grades: {
+							smart: { model: "claude-opus-4-6" },
+							normal: { model: "opus" },
+							cheap: { model: "sonnet" },
+						},
+						agents: {},
+						fallback: "normal",
+					},
+				},
+			},
+		} as unknown as ProfileManifest);
+
+		expect(
+			errors.some((e) => e.path === "profiles.p.models.grades.smart.model"),
+		).toBe(true);
+	});
+
+	test("a valid models block reports nothing", () => {
+		const errors = validateManifest({
+			version: 2,
+			profiles: {
+				p: {
+					name: "P",
+					models: {
+						version: 1,
+						preset: "fable-advisor",
+						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" },
+						fallback: "normal",
+					},
+				},
+			},
+		} as unknown as ProfileManifest);
+
+		expect(errors).toEqual([]);
+	});
+});
+
+describe("mergeManifestSettings", () => {
+	let dir: string;
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "manifest-merge-"));
+	});
+	afterEach(async () => {
+		await rm(dir, { recursive: true, force: true });
+	});
+
+	test("merges into the entry's settings, keeping what was there", async () => {
+		await writeManifest(
+			{
+				version: 2,
+				profiles: { p: { name: "P", settings: { outputStyle: "direct" } } },
+			},
+			dir,
+		);
+
+		expect(await mergeManifestSettings(dir, "p", { model: "opus" })).toBe(true);
+
+		const m = await readManifest(dir);
+		expect(m.profiles.p!.settings).toEqual({
+			outputStyle: "direct",
+			model: "opus",
+		});
+		expect(m.profiles.p!.updatedAt).toBeDefined();
+	});
+
+	test("unset removes keys outright, not as undefined", async () => {
+		await writeManifest(
+			{
+				version: 2,
+				profiles: { p: { name: "P", settings: { model: "opus", keep: 1 } } },
+			},
+			dir,
+		);
+
+		await mergeManifestSettings(dir, "p", {}, { unset: ["model"] });
+
+		const raw = await fs.readJson(join(dir, ".claude", "profiles.json"));
+		expect("model" in raw.profiles.p.settings).toBe(false);
+		expect(raw.profiles.p.settings.keep).toBe(1);
+	});
+
+	test("false, not an error, when there is nothing to record against", async () => {
+		expect(await mergeManifestSettings(dir, "p", { model: "opus" })).toBe(
+			false,
+		);
+		expect(await mergeManifestSettings(dir, null, { model: "opus" })).toBe(
+			false,
+		);
+
+		await writeManifest(
+			{ version: 2, profiles: { other: { name: "O" } } },
+			dir,
+		);
+		expect(await mergeManifestSettings(dir, "p", { model: "opus" })).toBe(
+			false,
+		);
+	});
+
+	// readManifest degrades a corrupt file to an empty manifest. Reusing it here
+	// would record nothing and report success, leaving the caller's live setting
+	// to be reverted by the next install with no way to learn why.
+	test("throws on an unreadable manifest instead of silently doing nothing", async () => {
+		await fs.outputFile(join(dir, ".claude", "profiles.json"), "{ not json");
+
+		await expect(
+			mergeManifestSettings(dir, "p", { model: "opus" }),
+		).rejects.toThrow(/not valid JSON/);
+
+		expect(
+			await fs.readFile(join(dir, ".claude", "profiles.json"), "utf8"),
+		).toBe("{ not json");
+	});
 });
 
 describe("readManifest / writeManifest", () => {