claudeup 6.3.2 → 6.5.0

package/src/services/settings-file.ts

@@ -0,0 +1,69 @@
+/**
+ * Read/modify/write a Claude Code `settings.json`, in place.
+ *
+ * Two rules, and both exist because of damage they prevent:
+ *
+ *  1. **Write IN PLACE, never remove-and-recreate.** `.claude/settings.json` is
+ *     a SYMLINK into `.claude/_profiles/<name>/` whenever a profile is active,
+ *     and `writeFile` follows it — which is what we want. Unlinking the file
+ *     first would break the link and silently detach the project from its
+ *     profile, leaving the next read looking at a fresh, empty file.
+ *  2. **Unparseable is an ERROR, not an empty object.** A settings file that
+ *     fails to parse is a file we do not understand, usually because a human is
+ *     mid-edit. Treating it as `{}` and writing our one key back is how a
+ *     user's whole configuration disappears. We refuse and say so.
+ *
+ * A MISSING file is different from an unparseable one: nothing is lost by
+ * starting from `{}`, so that is what a missing (or empty) file reads as.
+ */
+
+import path from "node:path";
+import fs from "fs-extra";
+
+/**
+ * Parse `settingsPath`. Missing or empty reads as `{}`; unparseable throws.
+ *
+ * Exported for callers that only need the read half — the refusal wording is
+ * the same either way, so nothing has to reimplement it.
+ */
+export async function readSettingsFile(
+	settingsPath: string,
+): Promise<Record<string, unknown>> {
+	if (!(await fs.pathExists(settingsPath))) return {};
+
+	const raw = (await fs.readFile(settingsPath, "utf8")).trim();
+	if (!raw) return {};
+
+	try {
+		return JSON.parse(raw) as Record<string, unknown>;
+	} catch (error) {
+		throw new Error(
+			`${settingsPath} is not valid JSON, refusing to overwrite it: ${String(error)}`,
+		);
+	}
+}
+
+/**
+ * Read, apply `mutate`, write back — preserving every key we did not touch.
+ *
+ * `mutate` may edit the object in place and return nothing, or return a
+ * replacement object. Nothing is written when the read throws, so a settings
+ * file we cannot parse is left exactly as the user left it.
+ */
+export async function updateSettingsFile(
+	settingsPath: string,
+	// biome-ignore lint/suspicious/noConfusingVoidType: the union IS the contract — mutate in place and return nothing, or return a replacement
+	mutate: (settings: Record<string, unknown>) => Record<string, unknown> | void,
+): Promise<void> {
+	const settings = await readSettingsFile(settingsPath);
+	const next =
+		(mutate(settings) as Record<string, unknown> | undefined) ?? settings;
+
+	await fs.ensureDir(path.dirname(settingsPath));
+	// writeFile, never remove-then-create: see rule 1 above.
+	await fs.writeFile(
+		settingsPath,
+		`${JSON.stringify(next, null, 2)}\n`,
+		"utf8",
+	);
+}

package/src/services/styles-manager.ts

@@ -37,7 +37,13 @@ import path from "node:path";
 import fs from "fs-extra";
 import { findCommunityStyle } from "../data/community-styles.js";
 import { EMBEDDED_PRESETS } from "../data/styles/index.js";
-import { getManifestPath, readManifest, writeManifest } from "./manifest.js";
+import {
+	getManifestPath,
+	mergeManifestSettings,
+	readManifest,
+	writeManifest,
+} from "./manifest.js";
+import { updateSettingsFile } from "./settings-file.js";
 import { activeProfile } from "./symlink-manager.js";
 
 // ─── Types ────────────────────────────────────────────────────────────────────
@@ -1051,58 +1057,35 @@ export function composeStyleFile(
 /**
  * Set `outputStyle` in settings.json, preserving everything else.
  *
- * Writes in place. `.claude/settings.json` may be a symlink into an active
- * profile's materialized directory — `writeFile` follows it, which is what we
- * want. Removing and recreating the file would break the link and silently
- * detach the project from its profile.
+ * Writes in place, and refuses a file it cannot parse — both are
+ * `updateSettingsFile`'s contract, and both are documented there.
  */
 async function setOutputStyle(
 	settingsPath: string,
 	styleName: string,
 ): Promise<void> {
-	let settings: Record<string, unknown> = {};
-	if (await fs.pathExists(settingsPath)) {
-		const raw = (await fs.readFile(settingsPath, "utf8")).trim();
-		if (raw) {
-			try {
-				settings = JSON.parse(raw) as Record<string, unknown>;
-			} catch (error) {
-				throw new Error(
-					`${settingsPath} is not valid JSON, refusing to overwrite it: ${String(error)}`,
-				);
-			}
-		}
-	}
-	settings.outputStyle = styleName;
-	await fs.ensureDir(path.dirname(settingsPath));
-	await fs.writeFile(
-		settingsPath,
-		`${JSON.stringify(settings, null, 2)}\n`,
-		"utf8",
-	);
+	await updateSettingsFile(settingsPath, (settings) => {
+		settings.outputStyle = styleName;
+	});
 }
 
 /**
  * Record the style in the committed manifest so it survives re-materialization.
  * Returns false when there is no active profile or no manifest entry for it —
  * both are normal, and neither is an error.
+ *
+ * `mergeManifestSettings` is shared with model routing, which writes the same
+ * `profiles.<name>.settings` for the same reason. It throws on a manifest it
+ * cannot parse rather than reporting a success it did not achieve.
  */
 async function recordInManifest(
 	projectPath: string,
 	profile: string | null,
 	styleName: string,
 ): Promise<boolean> {
-	if (!profile) return false;
-	if (!(await fs.pathExists(getManifestPath(projectPath)))) return false;
-
-	const manifest = await readManifest(projectPath);
-	const entry = manifest.profiles[profile];
-	if (!entry) return false;
-
-	entry.settings = { ...(entry.settings ?? {}), outputStyle: styleName };
-	entry.updatedAt = new Date().toISOString();
-	await writeManifest(manifest, projectPath);
-	return true;
+	return mergeManifestSettings(projectPath, profile, {
+		outputStyle: styleName,
+	});
 }
 
 export interface ApplyStylesArgs {
@@ -1285,20 +1268,15 @@ export async function createTeamStyle(
  */
 export async function clearStyle(projectPath: string): Promise<void> {
 	const settingsPath = settingsPathFor(projectPath);
+	// The guard stays: a project that never had a style must not gain a
+	// settings.json just because the style was cleared.
 	if (await fs.pathExists(settingsPath)) {
-		const raw = (await fs.readFile(settingsPath, "utf8")).trim();
-		if (raw) {
-			const settings = JSON.parse(raw) as Record<string, unknown>;
+		await updateSettingsFile(settingsPath, (settings) => {
 			// The key must be ABSENT, not present-and-undefined: Claude Code reads
 			// presence, and an `= undefined` assignment still answers `in` checks.
 			// biome-ignore lint/performance/noDelete: removal is the intent, not a shortcut
 			delete settings.outputStyle;
-			await fs.writeFile(
-				settingsPath,
-				`${JSON.stringify(settings, null, 2)}\n`,
-				"utf8",
-			);
-		}
+		});
 	}
 
 	const profile = await activeProfile(projectPath);

package/src/services/symlink-manager.ts

@@ -8,10 +8,17 @@
  *   .claude/settings.json  ->  .claude/_profiles/<name>/settings.json
  *   .claude/skills         ->  .claude/_profiles/<name>/skills
  *   .mcp.json              ->  .claude/_profiles/<name>/mcp.json
+ *   .claude/models.json    ->  .claude/_profiles/<name>/models.json
  *
  * Switching profiles just repoints these links — no network, no reinstall.
  * settings.local.json is NEVER linked: it holds personal credentials and must
  * survive switches untouched.
+ *
+ * models.json is the one link whose target is OPTIONAL: a profile that declares
+ * no routing has none, and the rule below (remove a link into _profiles/ whose
+ * target is gone) is what keeps a dangling `.claude/models.json` out of the
+ * repo. A dangling one would not be harmless — `.claude/` is committed, so it
+ * would ship to every teammate.
  */
 
 import path from "node:path";
@@ -27,6 +34,7 @@ export const PROFILE_GITIGNORE_ENTRIES = [
 	".claude/_profiles/",
 	".claude/settings.json",
 	".claude/skills",
+	".claude/models.json",
 	".mcp.json",
 ];
 
@@ -41,26 +49,37 @@ export function profileDir(name: string, projectPath?: string): string {
 	return path.join(profilesRoot(projectPath), name);
 }
 
+/** The artifacts an active profile links into place. */
+export type ProfileLinkKey = "settings" | "skills" | "mcp" | "models";
+
 /** The set of links an active profile owns, as [linkPath, targetPath] pairs. */
-function linkTargets(
+export function linkTargets(
 	name: string,
 	projectPath?: string,
-): Array<{ link: string; target: string }> {
+): Array<{ key: ProfileLinkKey; link: string; target: string }> {
 	const base = projectPath ?? process.cwd();
 	const dir = profileDir(name, projectPath);
 	return [
 		{
+			key: "settings",
 			link: path.join(base, ".claude", "settings.json"),
 			target: path.join(dir, "settings.json"),
 		},
 		{
+			key: "skills",
 			link: path.join(base, ".claude", "skills"),
 			target: path.join(dir, "skills"),
 		},
 		{
+			key: "mcp",
 			link: path.join(base, ".mcp.json"),
 			target: path.join(dir, "mcp.json"),
 		},
+		{
+			key: "models",
+			link: path.join(base, ".claude", "models.json"),
+			target: path.join(dir, "models.json"),
+		},
 	];
 }
 
@@ -93,16 +112,43 @@ export async function activateProfile(
 		);
 	}
 	for (const { link, target } of linkTargets(name, projectPath)) {
-		if (await fs.pathExists(target)) {
-			await relink(link, target);
-		} else {
-			// Profile doesn't provide this artifact — remove a stale link only if
-			// it currently points into a profile dir (don't clobber a real file).
-			if (await isProfileLink(link, projectPath)) {
-				await fs.remove(link);
-			}
-		}
+		await syncLink(link, target, projectPath);
+	}
+}
+
+/**
+ * Point one link at its target, or remove it when the profile has no such
+ * artifact. A link is only removed when it points into `_profiles/` — a real
+ * file the user put there is never clobbered.
+ */
+async function syncLink(
+	link: string,
+	target: string,
+	projectPath?: string,
+): Promise<void> {
+	if (await fs.pathExists(target)) {
+		await relink(link, target);
+		return;
 	}
+	if (await isProfileLink(link, projectPath)) await fs.remove(link);
+}
+
+/**
+ * Sync ONE of the active profile's links, leaving the others alone.
+ *
+ * `activateProfile` repoints all four, which is right when switching profiles
+ * and wrong when only one artifact changed: `claudeup models use` would replace
+ * a project's real `.mcp.json` with a symlink as a side effect of choosing a
+ * model. This is the narrow door for that case.
+ */
+export async function syncProfileLink(
+	name: string,
+	key: ProfileLinkKey,
+	projectPath?: string,
+): Promise<void> {
+	const entry = linkTargets(name, projectPath).find((t) => t.key === key);
+	if (!entry) return;
+	await syncLink(entry.link, entry.target, projectPath);
 }
 
 /** Is `link` a symlink pointing into `.claude/_profiles/`? */

package/src/tui.tsx

@@ -0,0 +1,112 @@
+/**
+ * The interactive TUI: renderer creation, theme resolution, and the React root.
+ *
+ * Split out of `main.tsx` so that nothing on a non-interactive path — above all
+ * `claudeup hook …`, which Claude Code runs on every matching tool call — has
+ * to load `@opentui/*` or `src/ui/` to reach its own code. `main.tsx` imports
+ * this module dynamically, at the last possible moment.
+ */
+
+import { RGBA, type ThemeMode, createCliRenderer } from "@opentui/core";
+import { createRoot } from "@opentui/react";
+import { App } from "./ui/App.js";
+import { setThemeMode } from "./ui/theme-mode.js";
+import { type ThemeEnv, resolveTheme } from "./ui/theme-resolve.js";
+
+export interface StartTuiOptions {
+	/** From `--theme`, already validated by the router. */
+	theme?: ThemeMode;
+	/** The theme variables, snapshotted in main.tsx BEFORE any .env merge. */
+	env: ThemeEnv;
+	/** stdin AND stdout are TTYs. Decided by the caller. */
+	isInteractive: boolean;
+}
+
+/**
+ * Start the TUI. Never resolves — the app runs until the user exits.
+ */
+export async function startTui({
+	theme,
+	env,
+	isInteractive,
+}: StartTuiOptions): Promise<void> {
+	// Create OpenTUI renderer (handles alternate screen buffer automatically).
+	//
+	// The background is the terminal's own, not a colour of ours: painting an
+	// absolute fill would box the UI into whatever theme we guessed. OpenTUI's
+	// built-in default for unstyled cells is truecolor white, which is why every
+	// element now names an adaptive colour explicitly — see src/ui/theme.ts.
+	// The mouse is ON, everywhere — it carries real features now: the wheel
+	// scrolls the pane under the cursor, and a drag selects text from ONE pane
+	// at a time (terminal-native selection is a screen-wide rectangle that
+	// grabs both columns), OSC 52-copied on release below.
+	//
+	// This deliberately includes tmux. Two earlier revisions got this wrong in
+	// opposite directions: one disabled the mouse everywhere on the theory that
+	// capture breaks tmux-level pane clicking, the next kept it off only inside
+	// tmux. Both dated from when claudeup had no mouse features, so disabling
+	// cost nothing. MEASURED on a heavily tmux'd machine: tmux forwards mouse
+	// to a pane application that asks for it (htop in the same session took
+	// clicks and wheel fine while claudeup sat inert), and tmux's own `mouse`
+	// option keeps governing pane management. Terminal-native selection stays
+	// reachable via Shift+drag in most terminals.
+	//
+	// enableMouseMovement (mode-1003 "report all motion") stays off — selection
+	// needs only button-held drag events, which button reporting delivers.
+	const renderer = await createCliRenderer({
+		backgroundColor: RGBA.defaultBackground(),
+		useMouse: true,
+		enableMouseMovement: false,
+	});
+
+	// Mouse selection → system clipboard, on release. OSC 52 survives SSH;
+	// terminals that block it simply ignore the sequence. Never fires where the
+	// mouse is off, so the tmux path pays nothing.
+	renderer.on("selection", (selection: { getSelectedText(): string }) => {
+		const text = selection?.getSelectedText() ?? "";
+		if (text.length > 0) renderer.copyToClipboardOSC52(text);
+	});
+
+	// Resolve light vs dark once: --theme, CLAUDEUP_THEME, TERM_THEME, the OSC
+	// probe, COLORFGBG, dark — see src/ui/theme-resolve.ts. Only the disabled-row
+	// tint and the chips need this (src/ui/theme-mode.ts explains why that one
+	// case cannot be solved the way the rest of the palette is).
+	//
+	// The renderer sends OSC 10/11 at creation regardless: @opentui/core 0.1.107
+	// has no option to suppress it. So the rule "TERM_THEME skips the probe" is
+	// satisfied by NOT AWAITING — when steps 1-3 answer, `probe` is never called,
+	// `waitForThemeMode(250)` never runs, first paint is not delayed, and
+	// `renderer.themeMode` is never read anywhere in claudeup. Any late reply the
+	// terminal sends is consumed by OpenTUI's own handleSequence and ignored here.
+	const { mode } = await resolveTheme({
+		flag: theme,
+		env,
+		isInteractive,
+		probe: () => renderer.waitForThemeMode(250).catch(() => null),
+	});
+	setThemeMode(mode);
+
+	const root = createRoot(renderer);
+
+	// Cleanup function to restore terminal
+	const cleanup = () => {
+		root.unmount();
+		renderer.destroy(); // CRITICAL: Never use process.exit() directly
+	};
+
+	// Handle cleanup on exit signals
+	const handleExit = () => {
+		cleanup();
+		// Exit after cleanup completes
+		process.exit(0);
+	};
+
+	process.on("SIGINT", handleExit);
+	process.on("SIGTERM", handleExit);
+
+	// Render the OpenTUI app with exit handler
+	root.render(<App onExit={handleExit} />);
+
+	// Wait indefinitely (app runs until user exits)
+	await new Promise(() => {});
+}

package/src/types/bun.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The sliver of Bun's global this project actually uses.
+ *
+ * `@types/bun` is deliberately NOT a dependency — `utils/command-utils.ts` says
+ * so where it reaches for Node's `fs` instead of `Bun.which` — and the whole
+ * package would be pulled in to type two properties. `cli/hook.ts` reads its
+ * payload from `Bun.stdin.stream()` because that is the fastest path on the
+ * hottest code claudeup has (a PreToolUse hook runs on every Agent call), so
+ * the global is declared here rather than the call being rewritten.
+ *
+ * Keep this MINIMAL. Every member added here is a member nobody checks against
+ * the real runtime; a full mirror of Bun's API would be a second, worse copy of
+ * `@types/bun` that drifts silently. If this grows past a few members, take the
+ * dependency instead.
+ */
+
+declare namespace Bun {
+	const stdin: {
+		stream(): AsyncIterable<Uint8Array>;
+	};
+}

package/src/types/index.ts

@@ -1,3 +1,5 @@
+import type { ModelsConfig } from "../services/models-core.js";
+
 export interface McpServer {
 	name: string;
 	description: string;
@@ -366,6 +368,12 @@ export interface ProfileManifestEntry {
 	cliTools?: Record<string, string>;
 	skills?: ProfileSkillRef[];
 	settings?: Record<string, unknown>;
+	/**
+	 * Per-subagent model routing. A PROFILE property, so switching profiles
+	 * switches routing, and materialization writes it to
+	 * `_profiles/<name>/models.json` for `.claude/models.json` to link at.
+	 */
+	models?: ModelsConfig;
 	env?: ProfileEnvRequirements;
 	/** Optional bookkeeping carried over from v1 saved profiles. */
 	createdAt?: string;
@@ -427,6 +435,12 @@ export interface ResolvedClosure {
 	bins: ResolvedBin[];
 	skills: ProfileSkillRef[];
 	settings: Record<string, unknown>;
+	/**
+	 * The profile's model routing, if it declares any. Absent means the
+	 * materialized profile carries no models.json — and materialization DELETES
+	 * a stale one, which is what makes `claudeup models off` take effect.
+	 */
+	models?: ModelsConfig;
 	env: { required: string[]; optional: string[] };
 	/** Cross-profile version conflicts detected while unioning profiles. */
 	conflicts?: string[];

package/src/ui/App.tsx

@@ -33,6 +33,7 @@ import {
 	GitignoreScreen,
 	McpRegistryScreen,
 	McpScreen,
+	ModelsScreen,
 	PluginsScreen,
 	ProfilesScreen,
 	SettingsScreen,
@@ -83,6 +84,8 @@ function Router() {
 			return <GitignoreScreen />;
 		case "alias":
 			return <AliasScreen />;
+		case "models":
+			return <ModelsScreen />;
 		default:
 			return <PluginsScreen />;
 	}
@@ -133,7 +136,8 @@ function GlobalKeyHandler({
 		// Don't handle keys when modal is open or searching
 		if (state.modal || state.isSearching) return;
 
-		// Global navigation shortcuts (1-9) - include mcp-registry as it's a sub-screen of mcp
+		// Global navigation shortcuts (1-9, then 0) - include mcp-registry as it's
+		// a sub-screen of mcp
 		const isTopLevel = [
 			"plugins",
 			"mcp",
@@ -145,6 +149,7 @@ function GlobalKeyHandler({
 			"styles",
 			"gitignore",
 			"alias",
+			"models",
 		].includes(state.currentRoute.screen);
 
 		if (isTopLevel) {
@@ -157,6 +162,7 @@ function GlobalKeyHandler({
 			else if (input === "7") navigateToScreen("gitignore");
 			else if (input === "8") navigateToScreen("alias");
 			else if (input === "9") navigateToScreen("styles");
+			else if (input === "0") navigateToScreen("models");
 
 			// Tab navigation cycling
 			if (key.tab) {
@@ -170,6 +176,7 @@ function GlobalKeyHandler({
 					"gitignore",
 					"alias",
 					"styles",
+					"models",
 				];
 				const currentIndex = screens.indexOf(
 					state.currentRoute.screen as Screen,
@@ -217,7 +224,7 @@ function GlobalKeyHandler({
   ?             This help
 
 Quick Navigation
-  1  Plugins      4  Settings    7  Git State
+  1  Plugins      4  Settings    7  Git State   0  Models
   2  Skills       5  Profiles    8  Alias
   3  MCP Servers  6  CLI Tools   9  Styles
 
@@ -233,7 +240,12 @@ Styles
   Space  Tick / untick a style
   a      Apply the selection to this project
   x      Reset the selection to what is live
-  c      Clear the active output style`,
+  c      Clear the active output style
+
+Models
+  a / Enter  Route this project through the selected preset
+  c          Turn model tiers off
+  r          Re-read the config`,
 				"info",
 			);
 		}