claudeup 6.3.2 → 6.4.0

package/src/services/hook-registration.ts

@@ -0,0 +1,218 @@
+/**
+ * Register `claudeup hook agent-model` as a `PreToolUse` hook on the Agent tool.
+ *
+ * The hook is what makes per-subagent routing exist at all: Claude Code has no
+ * per-agent model knob, and a PreToolUse hook rewriting the Agent tool's input
+ * is the only dynamic seam (measured — see `models-core.ts`). A config with no
+ * hook registered routes NOTHING, which is why `computeModelsStatus` reports
+ * `unhooked` ahead of any drift.
+ *
+ * Three rules, each earned:
+ *
+ *  1. **Identity is the command string.** Registration is idempotent because it
+ *     looks for the command, not for a block shape. An existing `Agent` matcher
+ *     block gets the command APPENDED rather than a second block created, so a
+ *     user's own Agent hooks keep running alongside this one.
+ *  2. **The command is BARE, never an absolute path.** `claudeup upgrade`
+ *     replaces the binary, and on npm the path carries a version directory — an
+ *     absolute path recorded today is a dead path after the next upgrade, and
+ *     the failure is invisible (a hook that cannot start is a hook that
+ *     silently does not route).
+ *  3. **User scope, through `updateSettingsFile`.** NOT
+ *     `readGlobalSettings`/`writeGlobalSettings`: those swallow a parse error
+ *     and return `{}`, so a settings file a human is mid-edit in would be
+ *     overwritten with one hook and nothing else. `updateSettingsFile` refuses
+ *     a file it cannot parse.
+ */
+
+import path from "node:path";
+import { claudeConfigDirOrNull } from "../utils/config-dir.js";
+import { readSettingsFile, updateSettingsFile } from "./settings-file.js";
+
+/** The command Claude Code runs. Bare — see rule 2 above. */
+export const AGENT_MODEL_HOOK_COMMAND = "claudeup hook agent-model";
+
+/** The tool whose input the hook rewrites. */
+const MATCHER = "Agent";
+
+/**
+ * Seconds. Generous for a process that reads one small JSON file and exits, and
+ * deliberately finite: Claude Code waits for this on every Agent call.
+ */
+const TIMEOUT_SECONDS = 5;
+
+interface HookCommand {
+	type: "command";
+	command: string;
+	timeout?: number;
+}
+
+const isRec = (v: unknown): v is Record<string, unknown> =>
+	typeof v === "object" && v !== null && !Array.isArray(v);
+
+/** The `hooks.PreToolUse` array, or [] for any shape that is not one. */
+function preToolUseBlocks(
+	settings: Record<string, unknown>,
+): Record<string, unknown>[] {
+	const hooks = settings.hooks;
+	if (!isRec(hooks)) return [];
+	const blocks = hooks.PreToolUse;
+	if (!Array.isArray(blocks)) return [];
+	return blocks.filter(isRec);
+}
+
+/** The command entries inside one matcher block. */
+function commandsIn(block: Record<string, unknown>): Record<string, unknown>[] {
+	return Array.isArray(block.hooks) ? block.hooks.filter(isRec) : [];
+}
+
+function isOurCommand(entry: Record<string, unknown>): boolean {
+	return (
+		typeof entry.command === "string" &&
+		entry.command.trim() === AGENT_MODEL_HOOK_COMMAND
+	);
+}
+
+/** Is the agent-model hook already registered in this settings object? */
+export function isHookRegistered(settings: Record<string, unknown>): boolean {
+	return preToolUseBlocks(settings).some((block) =>
+		commandsIn(block).some(isOurCommand),
+	);
+}
+
+function newCommandEntry(): HookCommand {
+	return {
+		type: "command",
+		command: AGENT_MODEL_HOOK_COMMAND,
+		timeout: TIMEOUT_SECONDS,
+	};
+}
+
+/**
+ * Add the hook if it is missing. Returns a NEW settings object — the input is
+ * never mutated, so a caller can diff before deciding to write.
+ */
+export function ensureHookRegistered(settings: Record<string, unknown>): {
+	settings: Record<string, unknown>;
+	changed: boolean;
+} {
+	if (isHookRegistered(settings)) return { settings, changed: false };
+
+	const next = structuredClone(settings);
+	const hooks = isRec(next.hooks) ? next.hooks : {};
+	const blocks = Array.isArray(hooks.PreToolUse) ? [...hooks.PreToolUse] : [];
+
+	// Append into an existing Agent block rather than adding a second one: two
+	// blocks with the same matcher both fire, which works, but it makes the
+	// user's settings file progressively less readable and is indistinguishable
+	// from a bug when they open it.
+	const existing = blocks.findIndex(
+		(b) => isRec(b) && b.matcher === MATCHER && Array.isArray(b.hooks),
+	);
+	if (existing >= 0) {
+		const block = blocks[existing] as Record<string, unknown>;
+		blocks[existing] = {
+			...block,
+			hooks: [...(block.hooks as unknown[]), newCommandEntry()],
+		};
+	} else {
+		blocks.push({ matcher: MATCHER, hooks: [newCommandEntry()] });
+	}
+
+	next.hooks = { ...hooks, PreToolUse: blocks };
+	return { settings: next, changed: true };
+}
+
+/**
+ * Remove every registration of the hook. An Agent block left with no commands
+ * is dropped, so uninstalling leaves no trace; other blocks and other commands
+ * inside a shared Agent block are untouched.
+ */
+export function removeHookRegistration(settings: Record<string, unknown>): {
+	settings: Record<string, unknown>;
+	changed: boolean;
+} {
+	if (!isHookRegistered(settings)) return { settings, changed: false };
+
+	const next = structuredClone(settings);
+	const hooks = next.hooks as Record<string, unknown>;
+	const blocks: unknown[] = [];
+	for (const block of hooks.PreToolUse as unknown[]) {
+		if (!isRec(block) || !Array.isArray(block.hooks)) {
+			blocks.push(block);
+			continue;
+		}
+		const kept = block.hooks.filter((e) => !(isRec(e) && isOurCommand(e)));
+		if (kept.length === 0 && block.matcher === MATCHER) continue;
+		blocks.push({ ...block, hooks: kept });
+	}
+
+	if (blocks.length > 0) {
+		hooks.PreToolUse = blocks;
+	} else {
+		// biome-ignore lint/performance/noDelete: an empty PreToolUse array is noise in a file people read
+		delete hooks.PreToolUse;
+	}
+	if (Object.keys(hooks).length === 0) {
+		// biome-ignore lint/performance/noDelete: same reason — leave no empty husk
+		delete next.hooks;
+	}
+	return { settings: next, changed: true };
+}
+
+/**
+ * The user-scope settings file this writes to.
+ *
+ * `claudeConfigDirOrNull` honours `CLAUDE_CONFIG_DIR` and returns null under
+ * `bun test` when no test has chosen a directory — which is a refusal, not a
+ * fallback: writing a hook into the operator's real `~/.claude/settings.json`
+ * from a test run is exactly the damage that guard exists to prevent.
+ */
+function userSettingsPath(configDir?: string): string {
+	const dir = configDir ?? claudeConfigDirOrNull();
+	if (!dir) {
+		throw new Error(
+			"No Claude config directory resolved. Set CLAUDE_CONFIG_DIR (a test must isolate it) before registering the agent-model hook.",
+		);
+	}
+	return path.join(dir, "settings.json");
+}
+
+/**
+ * Register the hook at user scope, once.
+ *
+ * User scope on purpose: routing is configured per project, but the hook that
+ * applies it has to be running in whatever session opens that project, and a
+ * project-scope hook would only exist for projects claudeup had already
+ * touched. The hook itself is a no-op for a project with no `models.json`, so
+ * one global registration costs nothing everywhere else.
+ */
+export async function registerAgentModelHook(
+	opts: { configDir?: string } = {},
+): Promise<"registered" | "already"> {
+	const settingsPath = userSettingsPath(opts.configDir);
+	// Read first so an unchanged file is not rewritten (and its mtime not
+	// touched) on every `models use`.
+	if (isHookRegistered(await readSettingsFile(settingsPath))) return "already";
+
+	await updateSettingsFile(settingsPath, (settings) => {
+		return ensureHookRegistered(settings).settings;
+	});
+	return "registered";
+}
+
+/** Is the hook registered in the user-scope settings file? */
+export async function isAgentModelHookRegistered(
+	opts: { configDir?: string } = {},
+): Promise<boolean> {
+	try {
+		return isHookRegistered(
+			await readSettingsFile(userSettingsPath(opts.configDir)),
+		);
+	} catch {
+		// No config dir, or a settings file we cannot parse. Either way we cannot
+		// claim it is registered — and the caller (doctor / status) reports that
+		// as "not routed", which is the honest answer.
+		return false;
+	}
+}

package/src/services/manifest.ts

@@ -10,6 +10,7 @@
 import path from "node:path";
 import fs from "fs-extra";
 import type { ProfileManifest, ProfileManifestEntry } from "../types/index.js";
+import { validateModelsConfig } from "./models-core.js";
 
 const PROFILES_FILE = "profiles.json";
 
@@ -160,7 +161,90 @@ export function validateManifest(
 				}
 			});
 		}
+		// Model routing is the one field here 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
+		// that stops a hand-edited entry reaching a session.
+		if (entry.models !== undefined) {
+			for (const e of validateModelsConfig(entry.models)) {
+				errors.push({
+					path: e.path ? `${base}.models.${e.path}` : `${base}.models`,
+					message: e.message,
+				});
+			}
+		}
 	}
 
 	return errors;
 }
+
+/**
+ * Read/modify/write ONE profile entry in the committed manifest.
+ *
+ * Returns false when there is nothing to record against (no profile named, no
+ * manifest file, or no entry for that profile) — all three are normal states,
+ * and `mutate` is not called.
+ *
+ * THROWS when the manifest exists and cannot be read as JSON. `readManifest`
+ * degrades a corrupt file to an empty manifest, which here would mean silently
+ * recording nothing and reporting success — the caller has just written a live
+ * setting the next `claudeup install` will revert, and would never learn.
+ */
+export async function updateProfileEntry(
+	projectPath: string,
+	profile: string | null,
+	mutate: (entry: ProfileManifestEntry) => void,
+): Promise<boolean> {
+	if (!profile) return false;
+	const filePath = getManifestPath(projectPath);
+	if (!(await fs.pathExists(filePath))) return false;
+
+	// Read directly rather than through readManifest: its `catch` is exactly
+	// what turns a corrupt file into a silent no-op.
+	let raw: unknown;
+	try {
+		raw = await fs.readJson(filePath);
+	} catch (error) {
+		throw new Error(
+			`${filePath} is not valid JSON, refusing to write to it: ${String(error)}`,
+		);
+	}
+
+	const manifest = migrateToV2(raw);
+	const entry = manifest.profiles[profile];
+	if (!entry) return false;
+
+	mutate(entry);
+	entry.updatedAt = new Date().toISOString();
+	await writeManifest(manifest, projectPath);
+	return true;
+}
+
+/**
+ * Merge `patch` into `profiles.<profile>.settings`, optionally removing the
+ * keys named in `unset`.
+ *
+ * Why this exists: `.claude/settings.json` is a symlink into the active
+ * profile's materialized directory, so a live write lands in the right place —
+ * but `materializeProfile` REWRITES that file from the manifest on every
+ * `claudeup install`, so the live write alone silently regresses. The manifest
+ * is the durable half of every settings write claudeup makes.
+ */
+export async function mergeManifestSettings(
+	projectPath: string,
+	profile: string | null,
+	patch: Record<string, unknown>,
+	opts: { unset?: readonly string[] } = {},
+): Promise<boolean> {
+	return updateProfileEntry(projectPath, profile, (entry) => {
+		const settings = { ...(entry.settings ?? {}), ...patch };
+		for (const key of opts.unset ?? []) {
+			// The key must be ABSENT, not present-and-undefined: an `= undefined`
+			// assignment still answers `in` checks, so the next call would read it
+			// as already handled and skip work it still owes.
+			delete settings[key];
+		}
+		entry.settings = settings;
+	});
+}