claudeup 4.18.0 → 4.22.0

package/src/cli/profile.ts

@@ -0,0 +1,166 @@
+/**
+ * `claudeup profile <list|show|switch|sync> [name]`
+ *
+ * Inspect and switch between team profiles materialized under
+ * `.claude/_profiles/`. Switching is cheap and offline — it just repoints the
+ * shared-config symlinks. `sync` (Phase 5) promotes local drift back into the
+ * committed manifest.
+ */
+
+import path from "node:path";
+import { readManifest } from "../services/manifest.js";
+import { resolveProfile } from "../services/resolver.js";
+import { summarizeClosure } from "../services/install-plan.js";
+import {
+	activateProfile,
+	activeProfile,
+	profileDir,
+	PROFILE_GITIGNORE_ENTRIES,
+} from "../services/symlink-manager.js";
+import { ensureGitignoreEntries } from "../services/conventions-manager.js";
+import { syncProfile } from "../services/profile-sync.js";
+import { checkBinaries, missingBinaries } from "../services/doctor-bins.js";
+import fs from "fs-extra";
+
+export async function runProfileCommand(args: string[]): Promise<number> {
+	const [sub, ...rest] = args;
+	const projectPath = process.cwd();
+
+	switch (sub) {
+		case undefined:
+		case "list":
+			return listProfiles(projectPath);
+		case "show":
+			return showProfile(rest[0], projectPath);
+		case "switch":
+			return switchProfile(rest[0], projectPath);
+		case "sync":
+			return syncActiveProfile(rest[0], projectPath);
+		default:
+			console.error(
+				`Unknown profile command "${sub}". Use: list | show <name> | switch <name> | sync`,
+			);
+			return 1;
+	}
+}
+
+export async function listProfiles(projectPath: string): Promise<number> {
+	const manifest = await readManifest(projectPath);
+	const ids = Object.keys(manifest.profiles);
+	if (ids.length === 0) {
+		console.log("No profiles defined in .claude/profiles.json.");
+		return 0;
+	}
+	const active = await activeProfile(projectPath);
+	console.log("Profiles:");
+	for (const id of ids) {
+		const entry = manifest.profiles[id]!;
+		const marker = id === active ? "●" : " ";
+		const materialized = (await fs.pathExists(profileDir(id, projectPath)))
+			? ""
+			: "  (not installed)";
+		console.log(`  ${marker} ${id} — ${entry.name}${materialized}`);
+	}
+	if (active) console.log(`\nActive: ${active}`);
+	return 0;
+}
+
+export async function showProfile(
+	name: string | undefined,
+	projectPath: string,
+): Promise<number> {
+	if (!name) {
+		console.error("Usage: claudeup profile show <name>");
+		return 1;
+	}
+	const manifest = await readManifest(projectPath);
+	if (!manifest.profiles[name]) {
+		console.error(
+			`Profile "${name}" not found. Available: ${Object.keys(manifest.profiles).join(", ")}`,
+		);
+		return 1;
+	}
+	const closure = await resolveProfile(manifest, name);
+	console.log(`Profile: ${name} (${manifest.profiles[name]!.name})`);
+	for (const line of summarizeClosure(closure)) console.log(`  ${line}`);
+	return 0;
+}
+
+export async function switchProfile(
+	name: string | undefined,
+	projectPath: string,
+): Promise<number> {
+	if (!name) {
+		console.error("Usage: claudeup profile switch <name>");
+		return 1;
+	}
+	const manifest = await readManifest(projectPath);
+	if (!manifest.profiles[name]) {
+		console.error(
+			`Profile "${name}" not found. Available: ${Object.keys(manifest.profiles).join(", ")}`,
+		);
+		return 1;
+	}
+	if (!(await fs.pathExists(profileDir(name, projectPath)))) {
+		console.error(
+			`Profile "${name}" isn't installed yet. Run: claudeup install ${name}`,
+		);
+		return 1;
+	}
+
+	// In profile mode the source of truth is .claude/profiles.json; the
+	// generated dir AND the per-developer symlinks must stay out of git so
+	// switching profiles causes no churn.
+	await ensureGitignoreEntries(
+		path.join(projectPath, ".gitignore"),
+		PROFILE_GITIGNORE_ENTRIES,
+		"# claudeup: generated profile build output + active-profile symlinks",
+	);
+
+	await activateProfile(name, projectPath);
+	console.log(`✓ Switched to profile: ${name}`);
+
+	// Verify the profile's binary deps are actually usable — the switch itself
+	// succeeds (symlinks are valid), but warn so "switched" isn't misleading.
+	try {
+		const closure = await resolveProfile(manifest, name);
+		const missing = missingBinaries(await checkBinaries(closure.bins));
+		if (missing.length > 0) {
+			console.log(
+				`\n⚠ ${missing.length} binary dependenc${missing.length === 1 ? "y is" : "ies are"} missing:`,
+			);
+			for (const m of missing) console.log(`  ✗ ${m.name} — run: ${m.installCommand}`);
+			console.log(`Run \`claudeup install ${name}\` to install them.`);
+		}
+	} catch {
+		// Verification is best-effort — never fail a valid switch on it.
+	}
+	return 0;
+}
+
+export async function syncActiveProfile(
+	nameArg: string | undefined,
+	projectPath: string,
+): Promise<number> {
+	const name = nameArg ?? (await activeProfile(projectPath));
+	if (!name) {
+		console.error(
+			"No active profile to sync. Pass a name: claudeup profile sync <name>",
+		);
+		return 1;
+	}
+	try {
+		const { changes, wrote } = await syncProfile(name, projectPath);
+		if (!wrote) {
+			console.log(`Profile "${name}" is already in sync with the manifest.`);
+			return 0;
+		}
+		console.log(`Synced "${name}" → .claude/profiles.json:`);
+		for (const c of changes) console.log(`  ${c.kind}: ${c.detail}`);
+		console.log("\nReview the diff and commit .claude/profiles.json.");
+		return 0;
+	} catch (e) {
+		console.error((e as Error).message);
+		return 1;
+	}
+}

package/src/cli/router.ts

@@ -0,0 +1,107 @@
+/**
+ * claudeup subcommand router.
+ *
+ * Parses argv and dispatches to a command handler. Commands run to completion
+ * and return an exit code; bare invocation (or an unknown token) falls through
+ * to the interactive TUI, preserving claudeup's historical behavior.
+ */
+
+import { checkForUpdates } from "../services/version-check.js";
+import { runClaudeCommand } from "./claude.js";
+import { runUpdateCommand } from "./update.js";
+import { runInstallCommand } from "./install.js";
+import { runProfileCommand } from "./profile.js";
+import { runDoctorCommand } from "./doctor.js";
+
+export interface RouteOutcome {
+	/** A subcommand (or top-level flag) handled the invocation. */
+	handled: boolean;
+	/** Exit code to use when `handled` is true. */
+	exitCode?: number;
+	/** No subcommand matched — the caller should launch the TUI. */
+	launchTui: boolean;
+}
+
+const HANDLED = (exitCode: number): RouteOutcome => ({
+	handled: true,
+	exitCode,
+	launchTui: false,
+});
+const LAUNCH_TUI: RouteOutcome = { handled: false, launchTui: true };
+
+export async function route(
+	argv: string[],
+	version: string,
+): Promise<RouteOutcome> {
+	// Top-level flags take precedence over any command token.
+	if (argv.includes("--version") || argv.includes("-v")) {
+		console.log(`claudeup v${version}`);
+		const result = await checkForUpdates();
+		if (result.updateAvailable) {
+			console.log(`\nUpdate available: v${result.latestVersion}`);
+			console.log("Run: claudeup update");
+		}
+		return HANDLED(0);
+	}
+
+	if (argv.includes("--help") || argv.includes("-h")) {
+		printHelp(version);
+		return HANDLED(0);
+	}
+
+	const [command, ...rest] = argv;
+
+	switch (command) {
+		case "claude":
+			return HANDLED(await runClaudeCommand(rest));
+		case "update":
+			return HANDLED(await runUpdateCommand());
+		case "install":
+			return HANDLED(await runInstallCommand(rest));
+		case "profile":
+			return HANDLED(await runProfileCommand(rest));
+		case "doctor":
+			return HANDLED(await runDoctorCommand(rest));
+		default:
+			// Bare `claudeup` or an unrecognized token → interactive TUI.
+			return LAUNCH_TUI;
+	}
+}
+
+function printHelp(version: string): void {
+	console.log(`claudeup v${version}
+
+TUI tool for managing Claude Code plugins, MCPs, and configuration.
+
+Usage: claudeup [options]
+       claudeup claude [args...]  Run claude with auto-update prerunner
+       claudeup update            Update claudeup to latest version
+
+Options:
+  -v, --version  Show version and check for updates
+  -h, --help     Show this help message
+  --no-refresh   Skip auto-refresh of marketplaces on startup
+
+Commands:
+  claude [args...]   Check for plugin updates (1h cache), then run claude
+    -f, --force      Force update check (bypass 1h cache)
+  update             Update claudeup itself to latest version
+
+Experimental (in development):
+  install [profile]  Install a team profile from .claude/profiles.json
+  profile <cmd>      list | show | switch | sync team profiles
+  doctor             Diagnose & repair plugin/marketplace/profile state
+
+Navigation (TUI):
+  [1] Plugins    [4] Settings   [7] Git State
+  [2] Skills     [5] Profiles   [8] Alias
+  [3] MCP        [6] CLI Tools
+
+Keys:
+  ↑/↓ or j/k     Navigate
+  Enter          Select / Toggle
+  r              Refresh current screen
+  ?              Show help
+  q / Escape     Back / Quit
+`);
+}

package/src/cli/update.ts

@@ -0,0 +1,85 @@
+/**
+ * `claudeup update` — self-update.
+ *
+ * Detects claudeup installs across bun + npm global, warns on duplicates
+ * (active vs shadowed), then re-installs `claudeup@latest` with whichever
+ * package manager owns the active binary. Resolves with the child's exit code.
+ */
+
+import { spawn } from "node:child_process";
+
+export async function runUpdateCommand(): Promise<number> {
+	const { execSync } = await import("node:child_process");
+	const { existsSync } = await import("node:fs");
+
+	// Detect all installations of claudeup across package managers
+	const installations: Array<{ manager: "bun" | "npm"; path: string }> = [];
+
+	// Check bun global
+	try {
+		const bunGlobalBin = execSync("bun pm -g bin", {
+			encoding: "utf-8",
+			timeout: 5000,
+		}).trim();
+		const bunPath = `${bunGlobalBin}/claudeup`;
+		if (existsSync(bunPath)) installations.push({ manager: "bun", path: bunPath });
+	} catch {
+		// bun not installed or no global claudeup
+	}
+
+	// Check npm global
+	try {
+		const npmPrefix = execSync("npm prefix -g", {
+			encoding: "utf-8",
+			timeout: 5000,
+		}).trim();
+		const npmPath = `${npmPrefix}/bin/claudeup`;
+		if (existsSync(npmPath)) installations.push({ manager: "npm", path: npmPath });
+	} catch {
+		// npm not installed or no global claudeup
+	}
+
+	// Warn about duplicate installations
+	if (installations.length > 1) {
+		const activePath = execSync("which claudeup", {
+			encoding: "utf-8",
+			timeout: 5000,
+		}).trim();
+
+		console.log(`⚠ claudeup is installed via multiple package managers:\n`);
+		for (const inst of installations) {
+			const tag = inst.path === activePath ? " (active)" : " (shadowed)";
+			console.log(`  ${inst.manager}: ${inst.path}${tag}`);
+		}
+		console.log(`\nTo fix, keep one and remove the other:`);
+		for (const inst of installations) {
+			console.log(`  ${inst.manager} uninstall -g claudeup`);
+		}
+		console.log();
+	}
+
+	// Determine which package manager to use for the update
+	let usesBun = false;
+	try {
+		const claudeupPath = execSync("which claudeup", {
+			encoding: "utf-8",
+		}).trim();
+		usesBun = claudeupPath.includes(".bun") || claudeupPath.includes("bun/bin");
+	} catch {
+		// If which fails, default to npm
+	}
+
+	const pkgManager = usesBun ? "bun" : "npm";
+	console.log(`Updating claudeup using ${pkgManager}...`);
+
+	const installArgs = ["install", "-g", "claudeup@latest"];
+
+	return new Promise<number>((resolve) => {
+		const proc = spawn(pkgManager, installArgs, {
+			stdio: "inherit",
+			shell: false, // Avoid shell for security (fixes DEP0190 warning)
+		});
+		proc.on("exit", (code) => resolve(code ?? 0));
+		proc.on("error", () => resolve(1));
+	});
+}

package/src/data/alias-flags.ts

@@ -222,6 +222,16 @@ export const ALIAS_FLAGS: AliasFlag[] = [
     description:
       "Path to a file whose contents are appended to the default system prompt.",
   },
+  {
+    id: "channels",
+    label: "Channels (approved)",
+    flag: "--channels",
+    kind: "text-list",
+    group: "channels",
+    description:
+      "Approved channel plugins/MCP servers to run this session (the allowlist). Channels derived from --dangerously-load appear in a separate section here and are unioned in on write; add your own approved channels on top.",
+    defaultValues: [],
+  },
   {
     id: "dangerously-load-development-channels",
     label: "Load development channels",
@@ -229,7 +239,7 @@ export const ALIAS_FLAGS: AliasFlag[] = [
     kind: "text-list",
     group: "channels",
     description:
-      "Sideload development channels from magus plugins. Default seed: claudish (the only magus plugin currently shipping channels).",
+      "Sideload development channels not on the approved allowlist (local dev only). Also shown under --channels and unioned into it on write. Default seed: claudish (the only magus plugin currently shipping channels).",
     defaultValues: ["plugin:claudish@magus"],
   },
   {

package/src/data/cli-tools.ts

@@ -6,7 +6,7 @@ export interface CliTool {
 	checkCommand: string;
 	website: string;
 	category: "ai-coding" | "utility";
-	packageManager: "npm" | "pip";
+	packageManager: "bun" | "npm" | "pip" | "brew" | "go";
 	packageName: string;
 }
 
@@ -16,11 +16,11 @@ export const cliTools: CliTool[] = [
 		displayName: "claudeup",
 		description:
 			"TUI tool for managing Claude Code plugins, MCPs, and configuration",
-		installCommand: "npm install -g claudeup",
+		installCommand: "bun install -g claudeup",
 		checkCommand: "claudeup --version",
 		website: "https://github.com/MadAppGang/magus/tree/main/tools/claudeup",
 		category: "ai-coding",
-		packageManager: "npm",
+		packageManager: "bun",
 		packageName: "claudeup",
 	},
 	{
@@ -28,22 +28,22 @@ export const cliTools: CliTool[] = [
 		displayName: "Mnemex",
 		description:
 			"AST-aware code search with PageRank, callers/callees, and semantic embeddings",
-		installCommand: "npm install -g mnemex",
+		installCommand: "bun install -g mnemex",
 		checkCommand: "mnemex --version",
 		website: "https://github.com/MadAppGang/mnemex",
 		category: "ai-coding",
-		packageManager: "npm",
+		packageManager: "bun",
 		packageName: "mnemex",
 	},
 	{
 		name: "claudish",
 		displayName: "Claudish",
 		description: "Run Claude Code with OpenRouter models (Grok, GPT-5, Gemini)",
-		installCommand: "npm install -g claudish",
+		installCommand: "bun install -g claudish",
 		checkCommand: "claudish --version",
 		website: "https://github.com/MadAppGang/claudish",
 		category: "ai-coding",
-		packageManager: "npm",
+		packageManager: "bun",
 		packageName: "claudish",
 	},
 	{

package/src/data/gitignore-defaults.ts

@@ -12,6 +12,8 @@ export const BUILTIN_DEFAULTS: GitignoreManifest = {
     ".claude/scheduled_tasks.lock",
     ".claude/cache/",
     ".claude/.statusline-worktree-*",
+    // Generated, per-developer profile build output (like node_modules).
+    ".claude/_profiles/",
     "ai-docs/sessions/",
     ".mnemex/",
     ".claudemem/",
@@ -19,6 +21,8 @@ export const BUILTIN_DEFAULTS: GitignoreManifest = {
     ".agents/",
   ],
   track: [
+    // The committed team source of truth when using profiles.
+    ".claude/profiles.json",
     ".claude/settings.json",
     ".mcp.json",
     "plugin.json",

package/src/data/marketplaces.ts

@@ -39,6 +39,18 @@ export const defaultMarketplaces: Marketplace[] = [
 		official: false,
 		featured: true, // Always show plugins (expanded by default)
 	},
+	{
+		name: "magus-marketing",
+		displayName: "Magus Marketing",
+		source: {
+			source: "github",
+			repo: "MadAppGang/magus-marketing",
+		},
+		description:
+			"SEO, cold email outreach, AI image generation, and video editing plugins",
+		official: false,
+		// Not featured: a niche channel, so keep it collapsed by default.
+	},
 	{
 		name: "claude-plugins-official",
 		displayName: "Anthropic Official",

package/src/data/predefined-profiles.ts

@@ -127,7 +127,6 @@ export const PREDEFINED_PROFILES: PredefinedProfile[] = [
 			"code-analysis",
 			"terminal",
 			"statusline",
-			"conductor",
 			"multimodel",
 			"gtd",
 		],
@@ -200,10 +199,10 @@ export const PREDEFINED_PROFILES: PredefinedProfile[] = [
 			"code-analysis",
 			"terminal",
 			"statusline",
-			"seo",
+			"seo@magus-marketing",
 			"browser-use",
-			"nanobanana",
-			"video-editing",
+			"nanobanana@magus-marketing",
+			"video-editing@magus-marketing",
 		],
 		anthropicPlugins: [
 			"explanatory-output-style",

package/src/main.tsx

@@ -2,15 +2,13 @@
 
 import { createCliRenderer } from "@opentui/core";
 import { createRoot } from "@opentui/react";
-import { spawn } from "node:child_process";
-import { createRequire } from "node:module";
 import { App } from "./ui/App.js";
-import { prerunClaude } from "./prerunner/index.js";
-import { checkForUpdates } from "./services/version-check.js";
+import { route } from "./cli/router.js";
+// Static import so `bun build --compile` embeds package.json into the binary;
+// a dynamic require("../package.json") is not resolvable inside the bunfs root.
+import pkg from "../package.json";
 
-const require = createRequire(import.meta.url);
-const pkg = require("../package.json") as { version: string };
-export const VERSION = pkg.version;
+export const VERSION = (pkg as { version: string }).version;
 
 // Note: OpenTUI renderer handles alternate screen buffer automatically
 // No need for manual ANSI escape codes
@@ -18,153 +16,12 @@ export const VERSION = pkg.version;
 async function main(): Promise<void> {
 	const args = process.argv.slice(2);
 
-	// Handle "claudeup claude [args]" - prerunner mode
-	if (args[0] === "claude") {
-		const claudeArgs = args.slice(1);
-
-		// Parse prerunner-specific flags
-		const forceUpdate =
-			claudeArgs.includes("--force") || claudeArgs.includes("-f");
-
-		// Remove prerunner flags before passing to claude
-		const filteredArgs = claudeArgs.filter(
-			(arg) => arg !== "--force" && arg !== "-f",
-		);
-
-		const exitCode = await prerunClaude(filteredArgs, { force: forceUpdate });
-		process.exit(exitCode);
-		return;
-	}
-
-	// Handle "claudeup update" - self-update command
-	if (args[0] === "update") {
-		const { execSync } = await import("node:child_process");
-		const { existsSync } = await import("node:fs");
-
-		// Detect all installations of claudeup across package managers
-		const installations: Array<{
-			manager: "bun" | "npm";
-			path: string;
-		}> = [];
-
-		// Check bun global
-		try {
-			const bunGlobalBin = execSync("bun pm -g bin", {
-				encoding: "utf-8",
-				timeout: 5000,
-			}).trim();
-			const bunPath = `${bunGlobalBin}/claudeup`;
-			if (existsSync(bunPath)) installations.push({ manager: "bun", path: bunPath });
-		} catch {
-			// bun not installed or no global claudeup
-		}
-
-		// Check npm global
-		try {
-			const npmPrefix = execSync("npm prefix -g", {
-				encoding: "utf-8",
-				timeout: 5000,
-			}).trim();
-			const npmPath = `${npmPrefix}/bin/claudeup`;
-			if (existsSync(npmPath)) installations.push({ manager: "npm", path: npmPath });
-		} catch {
-			// npm not installed or no global claudeup
-		}
-
-		// Warn about duplicate installations
-		if (installations.length > 1) {
-			const activePath = execSync("which claudeup", {
-				encoding: "utf-8",
-				timeout: 5000,
-			}).trim();
-
-			console.log(
-				`⚠ claudeup is installed via multiple package managers:\n`,
-			);
-			for (const inst of installations) {
-				const tag =
-					inst.path === activePath ? " (active)" : " (shadowed)";
-				console.log(`  ${inst.manager}: ${inst.path}${tag}`);
-			}
-			console.log(`\nTo fix, keep one and remove the other:`);
-			for (const inst of installations) {
-				console.log(`  ${inst.manager} uninstall -g claudeup`);
-			}
-			console.log();
-		}
-
-		// Determine which package manager to use for the update
-		let usesBun = false;
-		try {
-			const claudeupPath = execSync("which claudeup", {
-				encoding: "utf-8",
-			}).trim();
-			usesBun =
-				claudeupPath.includes(".bun") || claudeupPath.includes("bun/bin");
-		} catch {
-			// If which fails, default to npm
-		}
-
-		const pkgManager = usesBun ? "bun" : "npm";
-		console.log(`Updating claudeup using ${pkgManager}...`);
-
-		const installArgs = ["install", "-g", "claudeup@latest"];
-
-		const proc = spawn(pkgManager, installArgs, {
-			stdio: "inherit",
-			shell: false, // Avoid shell for security (fixes DEP0190 warning)
-		});
-		proc.on("exit", (code) => process.exit(code || 0));
-		return;
-	}
-
-	// Handle --version flag - show version and check for updates
-	if (args.includes("--version") || args.includes("-v")) {
-		console.log(`claudeup v${VERSION}`);
-		const result = await checkForUpdates();
-		if (result.updateAvailable) {
-			console.log(`\nUpdate available: v${result.latestVersion}`);
-			console.log("Run: claudeup update");
-		}
-		process.exit(0);
-	}
-
-	// Handle --help flag
-	if (args.includes("--help") || args.includes("-h")) {
-		console.log(`claudeup v${VERSION}
-
-TUI tool for managing Claude Code plugins, MCPs, and configuration.
-
-Usage: claudeup [options]
-       claudeup claude [args...]  Run claude with auto-update prerunner
-       claudeup update            Update claudeup to latest version
-
-Options:
-  -v, --version  Show version and check for updates
-  -h, --help     Show this help message
-  --no-refresh   Skip auto-refresh of marketplaces on startup
-
-Commands:
-  claude [args...]   Check for plugin updates (1h cache), then run claude
-    -f, --force      Force update check (bypass 1h cache)
-  update             Update claudeup itself to latest version
-
-Navigation:
-  [1] Plugins    Manage plugin marketplaces and installed plugins
-  [2] MCP        Setup and manage MCP servers
-  [3] Status     Configure status line display
-  [4] Env        Environment variables for MCP servers
-  [5] Tools      Install and update AI coding CLI tools
-
-Keys:
-  ↑/↓ or j/k     Navigate
-  Enter          Select / Toggle
-  g              Toggle global/project scope (in Plugins)
-  r              Refresh current screen
-  ?              Show help
-  q / Escape     Back / Quit
-`);
-		process.exit(0);
+	// Dispatch non-interactive subcommands (claude, update, install, …) and
+	// top-level flags (--version/--help). A bare invocation falls through to
+	// the interactive TUI below.
+	const outcome = await route(args, VERSION);
+	if (outcome.handled) {
+		process.exit(outcome.exitCode ?? 0);
 	}
 
 	// Create OpenTUI renderer (handles alternate screen buffer automatically)