claudeup 4.18.0 → 4.22.0

package/src/services/toolchain.ts

@@ -0,0 +1,97 @@
+/**
+ * Toolchain detection + bootstrap for the package managers a profile's binary
+ * deps need (bun, brew, npm, pip, go).
+ *
+ * `claudeup install` requires whatever installers the resolved closure uses. In
+ * source form bun is already guaranteed (bin/claudeup.js hard-exits without it),
+ * but once claudeup ships as a compiled binary an end user may lack bun — so bun
+ * is treated as a bootstrappable toolchain exactly like brew.
+ */
+
+import type { BinInstaller, ResolvedBin } from "../types/index.js";
+import { which } from "../utils/command-utils.js";
+
+/** The executable that proves a toolchain is installed. */
+const TOOLCHAIN_PROBE: Record<BinInstaller, string> = {
+	bun: "bun",
+	brew: "brew",
+	npm: "npm",
+	pip: "pip",
+	go: "go",
+};
+
+/** Official one-line bootstrap for the toolchains claudeup will install. */
+export const TOOLCHAIN_BOOTSTRAP: Partial<Record<BinInstaller, string>> = {
+	bun: "curl -fsSL https://bun.sh/install | bash",
+	brew: '/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"',
+};
+
+export interface ToolchainStatus {
+	name: BinInstaller;
+	present: boolean;
+	/** Binary names in the closure that need this toolchain. */
+	requiredBy: string[];
+	/** Bootstrap command, when claudeup can install this toolchain itself. */
+	bootstrap?: string;
+}
+
+/** Is a given toolchain available on PATH? */
+export async function isToolchainPresent(name: BinInstaller): Promise<boolean> {
+	return (await which(TOOLCHAIN_PROBE[name])) !== null;
+}
+
+/**
+ * Determine which toolchains a resolved closure's binary deps require, and
+ * whether each is present. Only toolchains actually needed are returned.
+ */
+export async function detectToolchains(
+	bins: ResolvedBin[],
+): Promise<ToolchainStatus[]> {
+	const requiredBy = new Map<BinInstaller, string[]>();
+	for (const bin of bins) {
+		const list = requiredBy.get(bin.via) ?? [];
+		list.push(bin.name);
+		requiredBy.set(bin.via, list);
+	}
+
+	const statuses: ToolchainStatus[] = [];
+	for (const [name, names] of requiredBy) {
+		statuses.push({
+			name,
+			present: await isToolchainPresent(name),
+			requiredBy: names,
+			bootstrap: TOOLCHAIN_BOOTSTRAP[name],
+		});
+	}
+	// Stable order: bun, brew, npm, pip, go.
+	const order: BinInstaller[] = ["bun", "brew", "npm", "pip", "go"];
+	statuses.sort((a, b) => order.indexOf(a.name) - order.indexOf(b.name));
+	return statuses;
+}
+
+/** The install command for a single binary requirement. */
+export function binInstallCommand(bin: {
+	name: string;
+	via: BinInstaller;
+	package?: string;
+	formula?: string;
+	module?: string;
+	version?: string;
+}): string {
+	const pkg = bin.package ?? bin.name;
+	const at = bin.version ? `@${bin.version}` : "";
+	switch (bin.via) {
+		case "bun":
+			return `bun install -g ${pkg}${at}`;
+		case "npm":
+			return `npm install -g ${pkg}${at}`;
+		case "pip":
+			return bin.version
+				? `pip install ${pkg}==${bin.version}`
+				: `pip install ${pkg}`;
+		case "brew":
+			return `brew install ${bin.formula ?? bin.name}`;
+		case "go":
+			return `go install ${bin.module ?? bin.name}@${bin.version ?? "latest"}`;
+	}
+}

package/src/services/version-check.ts

@@ -1,7 +1,5 @@
-import { createRequire } from "node:module";
 import semver from "semver";
-
-const require = createRequire(import.meta.url);
+import pkg from "../../package.json";
 
 // Cache the result for the session
 let cachedResult: VersionCheckResult | null = null;
@@ -14,15 +12,12 @@ export interface VersionCheckResult {
 }
 
 /**
- * Get the current version from package.json
+ * Get the current version from package.json.
+ * Static import so it resolves inside a `bun build --compile` binary — a
+ * dynamic require("../../package.json") returns no `.version` there.
  */
 export function getCurrentVersion(): string {
-	try {
-		const pkg = require("../../package.json");
-		return pkg.version;
-	} catch {
-		return "0.0.0";
-	}
+	return (pkg as { version?: string }).version ?? "0.0.0";
 }
 
 /**
@@ -97,7 +92,11 @@ export async function checkForUpdates(): Promise<VersionCheckResult> {
 		return cachedResult;
 	}
 
-	const updateAvailable = semver.gt(latestVersion, currentVersion);
+	// Guard: never let a malformed version crash the update check.
+	const updateAvailable =
+		semver.valid(latestVersion) != null &&
+		semver.valid(currentVersion) != null &&
+		semver.gt(latestVersion, currentVersion);
 
 	cachedResult = {
 		currentVersion,

package/src/types/index.ts

@@ -60,12 +60,6 @@ export interface Plugin {
 	hasUpdate?: boolean;
 }
 
-export interface StatusLineConfig {
-	name: string;
-	description: string;
-	template: string;
-}
-
 export interface MarketplaceSource {
 	source: {
 		source: "github";
@@ -250,6 +244,35 @@ export interface InstalledPluginsRegistry {
 	plugins: Record<string, InstalledPluginEntry[]>;
 }
 
+// ─── Plugin Conventions (declarative project hygiene) ───────────────────────────
+
+/** Convention declarations for a plugin */
+export interface PluginConventions {
+	gitignore?: GitignoreConventions;
+	claudemd?: ClaudeMdConventions;
+}
+
+/** Gitignore entries a plugin needs */
+export interface GitignoreConventions {
+	/** Entries for project .gitignore (team-visible, committed) */
+	project?: string[];
+	/** Advisory entries for global gitignore (personal, not committed).
+	 *  Resolved via `git config --global core.excludesfile`,
+	 *  falling back to ~/.config/git/ignore if unset. */
+	global?: string[];
+}
+
+/** CLAUDE.md section injection config */
+export interface ClaudeMdConventions {
+	/** Section identifier used in markers: <!-- BEGIN magus:{section} -->
+	 *  MUST equal the plugin's `name` field. */
+	section: string;
+	/** Path to markdown template, relative to plugin root */
+	template: string;
+	/** Semantic version of the template content */
+	version: string;
+}
+
 // ─── Plugin Profile Types ──────────────────────────────────────────────────────
 
 export interface Profile {
@@ -274,35 +297,119 @@ export interface ProfileEntry {
 	scope: "user" | "project";
 }
 
-// ─── Predefined Profile Types ──────────────────────────────────────────────────
+// NOTE: The built-in profile type lives with its data in
+// data/predefined-profiles.ts (that file declares and exports its own
+// PredefinedProfile). A second, unused definition previously lived here and
+// has been removed to avoid two competing shapes.
+
+// ─── Team Profile Manifest (v2, committed .claude/profiles.json) ────────────────
+//
+// The v1 `Profile`/`ProfilesFile` above are the TUI's saved presets (plugins
+// only). The v2 manifest below is the committed, team-shared source of truth:
+// a superset that also carries marketplaces, MCP servers, CLI tools, skills,
+// settings, and env requirements. A v1 profile is a structural subset of a v2
+// entry, so v1 files migrate forward by a version bump alone.
+
+/** A marketplace a profile depends on (registered before its plugins install). */
+export interface ProfileMarketplaceRef {
+	source: "github" | "directory";
+	/** owner/repo — for source: "github" */
+	repo?: string;
+	/** absolute or repo-relative path — for source: "directory" */
+	path?: string;
+}
 
-/** A skill reference for predefined profiles */
-export interface PredefinedSkill {
+/** A skill a profile installs (resolved from a GitHub repo + path). */
+export interface ProfileSkillRef {
 	name: string;
 	repo: string;
-	skillPath: string;
-}
-
-/** Settings that can be configured in a predefined profile */
-export interface PredefinedSettings {
-	effortLevel?: "low" | "medium" | "high";
-	alwaysThinkingEnabled?: boolean;
-	model?: "claude-sonnet-4-6" | "claude-opus-4-6";
-	outputStyle?: "concise" | "explanatory" | "formal";
-	CLAUDE_CODE_ENABLE_TASKS?: boolean;
-	CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS?: boolean;
-	includeGitInstructions?: boolean;
-	respectGitignore?: boolean;
-	enableAllProjectMcpServers?: boolean;
+	path: string;
 }
 
-/** A predefined (built-in) profile for claudeup */
-export interface PredefinedProfile {
-	id: string;
+/** Environment variables a profile declares (values live in settings.local.json). */
+export interface ProfileEnvRequirements {
+	required?: string[];
+	optional?: string[];
+}
+
+/**
+ * A single team profile in .claude/profiles.json (v2).
+ * `plugins` maps a plugin id to a version pin ("1.2.0"), "latest", or `true`
+ * (equivalent to "latest" — the shape v1 saved profiles use).
+ */
+export interface ProfileManifestEntry {
 	name: string;
-	description: string;
-	targetAudience: string;
-	plugins: Record<string, boolean>;
-	skills: PredefinedSkill[];
-	settings: PredefinedSettings;
+	/** Optional predefined-profile id to inherit plugins/skills/settings from. */
+	extends?: string;
+	marketplaces?: Record<string, ProfileMarketplaceRef>;
+	plugins?: Record<string, string | boolean>;
+	mcpServers?: Record<string, McpServerConfig>;
+	/** cliTool name -> version pin | "latest". */
+	cliTools?: Record<string, string>;
+	skills?: ProfileSkillRef[];
+	settings?: Record<string, unknown>;
+	env?: ProfileEnvRequirements;
+	/** Optional bookkeeping carried over from v1 saved profiles. */
+	createdAt?: string;
+	updatedAt?: string;
+}
+
+/** The .claude/profiles.json manifest (v2). */
+export interface ProfileManifest {
+	version: 2;
+	/** When true, `install --check` fails on any plugin version drift. */
+	strictVersions?: boolean;
+	profiles: Record<string, ProfileManifestEntry>;
+}
+
+// ─── Plugin binary requirements (plugin.json `requires.bin`) ────────────────────
+
+/** How a binary dependency is installed. */
+export type BinInstaller = "bun" | "brew" | "npm" | "pip" | "go";
+
+/** A single binary dependency a plugin (or profile) declares. */
+export interface BinRequirement {
+	/** The executable name expected on PATH (also the dedup key). */
+	name: string;
+	via: BinInstaller;
+	/** Package id for bun/npm/pip (defaults to `name`). */
+	package?: string;
+	/** Formula for brew (defaults to `name`). */
+	formula?: string;
+	/** Module path for `go install` (defaults to `name`). */
+	module?: string;
+	/** Command that verifies presence, e.g. "tmux -V" (defaults to `<name> --version`). */
+	check?: string;
+	/** Optional version pin (real for bun/npm/pip; advisory for brew/go). */
+	version?: string;
+}
+
+/** The `requires` block a plugin may declare in its plugin.json. */
+export interface PluginRequires {
+	bin?: BinRequirement[];
+}
+
+// ─── Resolved install closure (resolver output) ─────────────────────────────────
+
+/** A binary requirement after dedup + pin precedence, with provenance. */
+export interface ResolvedBin extends BinRequirement {
+	/** Where this requirement came from, for diagnostics. */
+	sources: string[];
+}
+
+/**
+ * The fully-resolved set of things to install for a profile (or the union of
+ * all profiles). Produced by the resolver; consumed by `claudeup install`.
+ */
+export interface ResolvedClosure {
+	marketplaces: Record<string, ProfileMarketplaceRef>;
+	/** pluginId -> version pin | "latest". */
+	plugins: Record<string, string>;
+	mcpServers: Record<string, McpServerConfig>;
+	bins: ResolvedBin[];
+	skills: ProfileSkillRef[];
+	settings: Record<string, unknown>;
+	env: { required: string[]; optional: string[] };
+	/** Cross-profile version conflicts detected while unioning profiles. */
+	conflicts?: string[];
 }

package/src/ui/App.tsx

@@ -18,7 +18,6 @@ import {
 	McpRegistryScreen,
 	SettingsScreen,
 	CliToolsScreen,
-	ModelSelectorScreen,
 	ProfilesScreen,
 	SkillsScreen,
 	GitignoreScreen,
@@ -72,8 +71,6 @@ function Router() {
 			return <SettingsScreen />;
 		case "cli-tools":
 			return <CliToolsScreen />;
-		case "model-selector":
-			return <ModelSelectorScreen />;
 		case "profiles":
 			return <ProfilesScreen />;
 		case "skills":
@@ -89,7 +86,7 @@ function Router() {
 
 /**
  * GlobalKeyHandler Component
- * Handles global keyboard shortcuts (1-5, Tab, Escape, q, ?, Shift+D)
+ * Handles global keyboard shortcuts (1-8, Tab, Escape, q, Ctrl+C, ?, Shift+D)
  * Does not render anything (returns null)
  */
 function GlobalKeyHandler({
@@ -139,7 +136,6 @@ function GlobalKeyHandler({
 			"mcp-registry",
 			"settings",
 			"cli-tools",
-			"model-selector",
 			"profiles",
 			"skills",
 			"gitignore",
@@ -180,16 +176,24 @@ function GlobalKeyHandler({
 			}
 		}
 
-		// Escape/q to go back or exit
-		if (key.escape || input === "q") {
+		// q or Ctrl+C quits from anywhere — no need to bounce to home first.
+		if (input === "q" || (key.ctrl && input === "c")) {
+			onExit();
+			return;
+		}
+
+		// Escape goes back: registry → mcp, any other tab → plugins home,
+		// already-home → exit. But when a screen has a focused sub-view open
+		// (e.g. the Alias flag-detail editor), that sub-view owns Escape and
+		// backs out to itself — don't let the global handler jump to home.
+		// Scoped to the Escape branch ONLY so q/Ctrl+C still quit from anywhere.
+		if (key.escape) {
+			if (state.detailActive) return;
 			if (state.currentRoute.screen === "plugins") {
-				// On home screen, exit immediately
 				onExit();
 			} else if (state.currentRoute.screen === "mcp-registry") {
-				// Go back to MCP from registry
 				navigateToScreen("mcp");
 			} else {
-				// Go back to plugins (home)
 				navigateToScreen("plugins");
 			}
 		}
@@ -201,7 +205,8 @@ function GlobalKeyHandler({
 				`Navigation
   ↑/↓ or j/k    Move selection
   Enter         Select / Toggle
-  Escape or q   Back / Quit
+  Escape        Back (to home)
+  q / Ctrl+C    Quit (from anywhere)
   ?             This help
 
 Quick Navigation

package/src/ui/components/modals/ConfirmModal.tsx

@@ -47,7 +47,7 @@ export function ConfirmModal({
 			<box marginBottom={1}>
 				<text fg="#A1A1AA">{message}</text>
 			</box>
-			<box marginTop={1}>
+			<box marginTop={1} flexDirection="row">
 				<text fg="#71717A">Press </text>
 				<text fg="#EDEDED">Y</text>
 				<text fg="#71717A"> to confirm • </text>