claudeup 4.34.0 → 4.35.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "4.34.0",
+  "version": "4.35.1",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -64,8 +64,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "claudeup-darwin-arm64": "4.34.0",
-    "claudeup-darwin-x64": "4.34.0",
-    "claudeup-linux-x64": "4.34.0"
+    "claudeup-darwin-arm64": "4.35.1",
+    "claudeup-darwin-x64": "4.35.1",
+    "claudeup-linux-x64": "4.35.1"
   }
 }

package/src/__tests__/git-worktree.test.ts

@@ -0,0 +1,108 @@
+import {
+	afterAll,
+	beforeAll,
+	beforeEach,
+	describe,
+	expect,
+	test,
+} from "bun:test";
+import { execFileSync } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import fs from "fs-extra";
+import {
+	clearWorktreeCache,
+	inheritablePaths,
+} from "../services/git-worktree.js";
+
+/**
+ * Exercised against real repositories rather than a mocked `git`, because the
+ * whole point of the function is agreeing with git about what a worktree is.
+ * A stub would have happily confirmed a wrong parse of `worktree list`.
+ */
+
+// Isolate from the operator's git config: a global `core.excludesFile`,
+// `init.defaultBranch`, or commit signing would otherwise leak into these repos.
+const GIT_CFG = [
+	"-c",
+	"user.name=test",
+	"-c",
+	"user.email=test@example.com",
+	"-c",
+	"commit.gpgsign=false",
+	"-c",
+	"init.defaultBranch=main",
+];
+
+const git = (cwd: string, ...args: string[]) =>
+	execFileSync("git", [...GIT_CFG, ...args], { cwd, encoding: "utf8" }).trim();
+
+let base: string;
+let mainTree: string;
+let linked: string;
+
+beforeAll(async () => {
+	// realpath: on macOS os.tmpdir() is a symlink, and git reports real paths.
+	base = await fs.realpath(
+		await fs.mkdtemp(path.join(os.tmpdir(), "claudeup-worktree-")),
+	);
+	mainTree = path.join(base, "repo");
+	linked = path.join(base, "linked");
+
+	await fs.ensureDir(mainTree);
+	git(mainTree, "init", "-q");
+	await fs.writeFile(path.join(mainTree, "README.md"), "hello\n");
+	git(mainTree, "add", "-A");
+	git(mainTree, "commit", "-qm", "initial");
+	git(mainTree, "worktree", "add", "-q", "-b", "feature", linked);
+});
+
+afterAll(async () => {
+	if (base) await fs.remove(base);
+});
+
+beforeEach(() => {
+	clearWorktreeCache();
+});
+
+describe("inheritablePaths", () => {
+	test("a linked worktree inherits from the main working tree", async () => {
+		expect(await inheritablePaths(linked)).toEqual([mainTree]);
+	});
+
+	test("the main working tree inherits nothing — it holds its own rows", async () => {
+		expect(await inheritablePaths(mainTree)).toEqual([]);
+	});
+
+	test("a subdirectory of a checkout inherits from the repository root", async () => {
+		const sub = path.join(mainTree, "packages", "app");
+		await fs.ensureDir(sub);
+		expect(await inheritablePaths(sub)).toEqual([mainTree]);
+	});
+
+	test("a subdirectory of a linked worktree inherits both roots, nearest first", async () => {
+		const sub = path.join(linked, "packages", "app");
+		await fs.ensureDir(sub);
+		expect(await inheritablePaths(sub)).toEqual([linked, mainTree]);
+	});
+
+	test("a directory outside any repository inherits nothing", async () => {
+		const loose = path.join(base, "not-a-repo");
+		await fs.ensureDir(loose);
+		// Guard: a stray repo above the temp dir would silently invalidate this.
+		const out = await inheritablePaths(loose);
+		expect(out.every((p) => !p.startsWith(base))).toBe(true);
+	});
+
+	test("a missing directory yields nothing rather than throwing", async () => {
+		expect(await inheritablePaths(path.join(base, "gone"))).toEqual([]);
+	});
+
+	test("results are cached per path and cleared on demand", async () => {
+		const first = await inheritablePaths(linked);
+		expect(await inheritablePaths(linked)).toBe(first); // same array identity
+		clearWorktreeCache();
+		expect(await inheritablePaths(linked)).not.toBe(first);
+		expect(await inheritablePaths(linked)).toEqual([mainTree]);
+	});
+});

package/src/__tests__/resolver.test.ts

@@ -216,3 +216,74 @@ describe("resolveAllProfiles — union", () => {
 		expect(union.conflicts?.some((c) => c.includes("claudish"))).toBe(true);
 	});
 });
+
+describe("marketplaces derived from plugin ids", () => {
+	const noBins = { binResolver: fakeBinResolver({}) };
+
+	test("a plugin id registers the marketplace it names", async () => {
+		const manifest = manifestOf({
+			solo: { name: "Solo", plugins: { "dev@magus": "latest" } },
+		});
+		const c = await resolveProfile(manifest, "solo", noBins);
+		expect(c.marketplaces.magus).toEqual({
+			source: "github",
+			repo: "MadAppGang/magus",
+		});
+	});
+
+	test("extends alone is enough — the failure this fixes", async () => {
+		// A profile that only extends a predefined one inherits plugins like
+		// dev@magus and previously NO marketplaces, so install resolved every
+		// plugin against a marketplace that was never registered.
+		const manifest = manifestOf({
+			team: { name: "Team", extends: "developer-essentials" },
+		});
+		const c = await resolveProfile(manifest, "team", noBins);
+		expect(Object.keys(c.plugins).length).toBeGreaterThan(0);
+		expect(c.marketplaces.magus?.repo).toBe("MadAppGang/magus");
+	});
+
+	test("each distinct channel is derived, not just the first", async () => {
+		const manifest = manifestOf({
+			mixed: {
+				name: "Mixed",
+				plugins: {
+					"dev@magus": "latest",
+					"seo@magus-marketing": "latest",
+					"autolinear@magus-alpha": "latest",
+				},
+			},
+		});
+		const c = await resolveProfile(manifest, "mixed", noBins);
+		expect(c.marketplaces["magus-marketing"]?.repo).toBe("MadAppGang/magus-marketing");
+		expect(c.marketplaces["magus-alpha"]?.repo).toBe("MadAppGang/magus-alpha");
+	});
+
+	test("an explicit declaration is never overridden", async () => {
+		const manifest = manifestOf({
+			pinned: {
+				name: "Pinned",
+				marketplaces: { magus: { source: "github", repo: "MadAppGang/magus-fork" } },
+				plugins: { "dev@magus": "latest" },
+			},
+		});
+		const c = await resolveProfile(manifest, "pinned", noBins);
+		expect(c.marketplaces.magus?.repo).toBe("MadAppGang/magus-fork");
+	});
+
+	test("an unknown marketplace is left for the manifest to declare", async () => {
+		const manifest = manifestOf({
+			third: { name: "Third", plugins: { "thing@someones-marketplace": "latest" } },
+		});
+		const c = await resolveProfile(manifest, "third", noBins);
+		expect(c.marketplaces["someones-marketplace"]).toBeUndefined();
+	});
+
+	test("a bare plugin id contributes no marketplace", async () => {
+		const manifest = manifestOf({
+			bare: { name: "Bare", plugins: { local: "latest" } },
+		});
+		const c = await resolveProfile(manifest, "bare", noBins);
+		expect(Object.keys(c.marketplaces)).toHaveLength(0);
+	});
+});

package/src/__tests__/worktree-registry-resolution.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test";
+import { pickRegistryEntry } from "../services/claude-settings.js";
+import type { InstalledPluginEntry } from "../types/index.js";
+
+/**
+ * Regression cover for "a fresh git worktree reports every plugin as not installed".
+ *
+ * `installed_plugins.json` keys one entry per `projectPath`, and a new worktree is
+ * a project path nobody has ever installed into — measured on a real machine:
+ * 750 project-scope rows, zero of them for the worktree, and zero user-scope rows
+ * for any magus plugin. So `pickRegistryEntry` found nothing, `overlayRegistryVersions`
+ * deleted the version as an unbacked claim, and `isInstalledInScope` reported the
+ * plugin missing.
+ *
+ * Claude Code disagreed: it loaded all of them. Its loader is not gated on the
+ * current project — a worktree with no rows resolves `installPath` from another
+ * project's row and loads from cache (measured, `ai-docs/plugin-system-state-model.md`).
+ * So claudeup was offering to install plugins that were already working.
+ *
+ * A linked worktree is the same project as its main working tree, so the main
+ * tree's row is the honest answer for it.
+ */
+
+const entry = (
+	scope: InstalledPluginEntry["scope"],
+	version: string,
+	projectPath?: string,
+): InstalledPluginEntry => ({
+	scope,
+	version,
+	projectPath,
+	installPath: `/cache/${version}`,
+	installedAt: "2026-01-01T00:00:00.000Z",
+	lastUpdated: "2026-01-01T00:00:00.000Z",
+});
+
+const MAIN = "/repo";
+const TREE = "/repo/.claude/worktrees/feature";
+
+describe("pickRegistryEntry — worktree fallback", () => {
+	test("a worktree with no rows of its own resolves to the main working tree's row", () => {
+		const entries = [entry("project", "3.3.0", MAIN)];
+		expect(pickRegistryEntry(entries, "project", TREE, [MAIN])?.version).toBe(
+			"3.3.0",
+		);
+	});
+
+	test("the worktree's own row still wins over the main tree's row", () => {
+		const entries = [
+			entry("project", "3.3.0", MAIN),
+			entry("project", "4.0.0", TREE),
+		];
+		expect(pickRegistryEntry(entries, "project", TREE, [MAIN])?.version).toBe(
+			"4.0.0",
+		);
+	});
+
+	test("a local-scope row on the main tree satisfies a worktree project lookup", () => {
+		const entries = [entry("local", "5.0.0", MAIN)];
+		expect(pickRegistryEntry(entries, "project", TREE, [MAIN])?.version).toBe(
+			"5.0.0",
+		);
+	});
+
+	test("the main-tree row outranks a user-scope entry", () => {
+		// Same project beats "installed globally somewhere". The user entry is the
+		// looser fallback and stays available when the main tree has no row.
+		const entries = [entry("user", "1.0.0"), entry("project", "3.3.0", MAIN)];
+		expect(pickRegistryEntry(entries, "project", TREE, [MAIN])?.version).toBe(
+			"3.3.0",
+		);
+	});
+
+	test("the user-scope entry still applies when the main tree has no row either", () => {
+		const entries = [
+			entry("user", "2.1.2"),
+			entry("project", "9.9.9", "/elsewhere"),
+		];
+		expect(pickRegistryEntry(entries, "project", TREE, [MAIN])?.version).toBe(
+			"2.1.2",
+		);
+	});
+
+	test("an unrelated project's row is never inherited", () => {
+		// The loader may well resolve one of these, but claudeup must not claim a
+		// version it cannot attribute to this project.
+		const entries = [entry("project", "9.9.9", "/some/other/project")];
+		expect(pickRegistryEntry(entries, "project", TREE, [MAIN])).toBeUndefined();
+	});
+
+	test("fallback paths are compared resolved, not as raw strings", () => {
+		const entries = [entry("project", "4.2.0", "/repo/./sub/..")];
+		expect(pickRegistryEntry(entries, "project", TREE, [MAIN])?.version).toBe(
+			"4.2.0",
+		);
+	});
+
+	test("fallback paths are ignored for a user-scope lookup", () => {
+		const entries = [entry("project", "3.3.0", MAIN)];
+		expect(pickRegistryEntry(entries, "user", TREE, [MAIN])).toBeUndefined();
+	});
+
+	test("omitting fallback paths preserves the previous behaviour", () => {
+		const entries = [entry("project", "3.3.0", MAIN)];
+		expect(pickRegistryEntry(entries, "project", TREE)).toBeUndefined();
+	});
+});

package/src/data/marketplaces.ts

@@ -53,6 +53,19 @@ export const defaultMarketplaces: Marketplace[] = [
 		owned: true, // Ours: always listed even when uninstalled, sorted to the top
 		// Not featured: a niche channel, so keep it collapsed by default.
 	},
+	{
+		name: "magus-alpha",
+		displayName: "Magus Alpha",
+		source: {
+			source: "github",
+			repo: "MadAppGang/magus-alpha",
+		},
+		description:
+			"Experimental plugins with evolving interfaces — may change or be withdrawn without notice",
+		official: false,
+		owned: true, // Ours: always listed even when uninstalled, sorted to the top
+		// Not featured: experimental, so keep it collapsed by default.
+	},
 	{
 		name: "claude-plugins-official",
 		displayName: "Anthropic Official",

package/src/services/claude-settings.ts

@@ -12,6 +12,7 @@ import type {
 	InstalledPluginEntry,
 } from "../types/index.js";
 import { parsePluginId } from "../utils/string-utils.js";
+import { inheritablePaths } from "./git-worktree.js";
 
 const CLAUDE_DIR = ".claude";
 const SETTINGS_FILE = "settings.json";
@@ -261,27 +262,44 @@ export async function getLocalEnabledPlugins(
  * The registry is what Claude Code actually loaded, so it wins on conflict.
  *
  * Scope resolution mirrors Claude Code: for a project scope, prefer an entry
- * pinned to that exact projectPath (project or local), then fall back to the
- * user-scope entry, which is what a project without its own install resolves to.
+ * pinned to that exact projectPath (project or local), then any `fallbackPaths`
+ * that are the same repository (see git-worktree.ts), then the user-scope entry,
+ * which is what a project without its own install resolves to.
  */
 export function pickRegistryEntry(
 	entries: InstalledPluginEntry[] | undefined,
 	scope: "user" | "project" | "local",
 	projectPath?: string,
+	/**
+	 * Same-repository directories whose rows may be inherited, nearest first —
+	 * a linked worktree's main working tree, or the root of this checkout.
+	 *
+	 * A fresh worktree has no rows of its own, so without this every plugin read
+	 * as not installed while Claude Code was loading all of them quite happily.
+	 * These rank above the user-scope entry: "installed in this repository" is a
+	 * closer answer than "installed globally somewhere".
+	 */
+	fallbackPaths: string[] = [],
 ): InstalledPluginEntry | undefined {
 	if (!Array.isArray(entries) || entries.length === 0) return undefined;
 
 	if (scope === "user") return entries.find((e) => e.scope === "user");
 
-	const target = projectPath ? path.resolve(projectPath) : undefined;
-	if (target) {
-		const pinned = entries.find(
+	const pinnedTo = (target: string) =>
+		entries.find(
 			(e) =>
 				(e.scope === scope || e.scope === "local") &&
 				e.projectPath !== undefined &&
 				path.resolve(e.projectPath) === target,
 		);
-		if (pinned) return pinned;
+
+	if (projectPath) {
+		const own = pinnedTo(path.resolve(projectPath));
+		if (own) return own;
+	}
+	for (const fallback of fallbackPaths) {
+		const inherited = pinnedTo(path.resolve(fallback));
+		if (inherited) return inherited;
 	}
 	// A project with no install of its own resolves to the user-scope entry.
 	return entries.find((e) => e.scope === "user");
@@ -299,9 +317,21 @@ async function overlayRegistryVersions(
 		return base; // registry unreadable — settings-only is still better than nothing
 	}
 
+	// `readSettings(undefined)` already resolves to the current directory, so the
+	// registry lookup has to as well. While it did not, the base map described one
+	// project while the overlay refused to match any project's rows at all, and every
+	// version was deleted as unbacked — which is why the prerunner and the global
+	// plugin view, both of which pass no path, saw project-scope plugins as
+	// uninstalled everywhere, not only in a worktree.
+	const target = scope === "user" ? undefined : (projectPath ?? process.cwd());
+
+	// Resolved once, not per plugin: this shells out to git, and the loop runs
+	// across every key in the registry (76 on a well-used machine) for each scope.
+	const fallbackPaths = target ? await inheritablePaths(target) : [];
+
 	const merged = { ...base };
 	for (const [pluginId, entries] of Object.entries(registry.plugins ?? {})) {
-		const pick = pickRegistryEntry(entries, scope, projectPath);
+		const pick = pickRegistryEntry(entries, scope, target, fallbackPaths);
 		if (pick?.version) {
 			merged[pluginId] = pick.version;
 			continue;

package/src/services/git-worktree.ts

@@ -0,0 +1,129 @@
+/**
+ * git-worktree.ts — which other directories count as "the same project" as this one.
+ *
+ * `installed_plugins.json` keys one entry per `projectPath`, so a directory that
+ * nobody has run `claude plugin install` in has no rows at all. A freshly created
+ * git worktree is exactly that: measured on a real machine, 750 project-scope rows
+ * across 76 plugin keys and not one of them for the new worktree.
+ *
+ * Claude Code does not care. Its loader is not gated on the current project — a
+ * worktree with zero rows resolves `installPath` from another project's row and
+ * loads from cache (measured, `ai-docs/plugin-system-state-model.md`). claudeup
+ * mirrored the registry faithfully instead, so it reported every plugin as missing
+ * and offered to install things that were already working.
+ *
+ * The fix is to ask a narrower question than "does the loader find something
+ * somewhere": inherit rows only from directories that are the *same repository*.
+ * That covers both ways a project path can miss its own rows —
+ *
+ *   1. a linked worktree, whose main working tree holds the rows
+ *   2. a subdirectory of a checkout, where the rows sit at the repo root
+ *
+ * — under one rule, and never inherits from an unrelated project, which would be
+ * claiming a version we cannot attribute.
+ */
+
+import { spawn } from "node:child_process";
+import path from "node:path";
+
+function git(
+	cwd: string,
+	args: string[],
+): Promise<{ code: number; out: string }> {
+	return new Promise((resolve) => {
+		const child = spawn("git", args, {
+			cwd,
+			stdio: ["ignore", "pipe", "ignore"],
+		});
+		let out = "";
+		child.stdout.on("data", (d) => {
+			out += String(d);
+		});
+		// Never let a wedged git block the UI.
+		const timer = setTimeout(() => {
+			child.kill();
+			resolve({ code: -1, out: "" });
+		}, 5000);
+		timer.unref?.();
+		const settle = (code: number, text: string) => {
+			clearTimeout(timer);
+			resolve({ code, out: text });
+		};
+		child.on("error", () => settle(-1, ""));
+		child.on("close", (code) => settle(code ?? -1, out.trim()));
+	});
+}
+
+/**
+ * Session cache. Keyed by resolved project path — the repository layout cannot
+ * change under a running claudeup in any way worth tracking, and the resolution
+ * runs once per plugin per scope otherwise (24+ plugins × 3 scopes of `git`).
+ */
+const cache = new Map<string, string[]>();
+
+export function clearWorktreeCache(): void {
+	cache.clear();
+}
+
+/**
+ * Directories whose registry rows this project may inherit, nearest first.
+ *
+ * Returns `[]` — never a guess — when the question cannot be answered honestly:
+ * git missing, not a repository, a bare repo with no working tree, or the path
+ * already being the repository root. Inheriting nothing restores the previous
+ * behaviour for that path, which is the safe direction: a false negative shows
+ * an "install" the user does not need, a false positive hides a real one.
+ */
+export async function inheritablePaths(projectPath: string): Promise<string[]> {
+	const key = path.resolve(projectPath);
+	const cached = cache.get(key);
+	if (cached) return cached;
+	const { paths, answered } = await resolveInheritable(key);
+	// Only cache an answer git actually gave. A timeout or a transient spawn
+	// failure would otherwise pin an empty result for the rest of the session,
+	// turning one slow moment into a persistent wrong "not installed".
+	if (answered) cache.set(key, paths);
+	return paths;
+}
+
+async function resolveInheritable(
+	dir: string,
+): Promise<{ paths: string[]; answered: boolean }> {
+	const candidates: string[] = [];
+
+	// Independent queries, so run them together: sequentially, two wedged git calls
+	// would stall the first paint for the full 10s rather than 5.
+	const [top, list] = await Promise.all([
+		// The root of whichever working tree we are standing in. Covers a subdirectory
+		// of a checkout, and is the nearer answer when both apply.
+		git(dir, ["rev-parse", "--show-toplevel"]),
+		// The main working tree, which `git worktree list` always lists first. This is
+		// the row-bearing directory for a linked worktree.
+		git(dir, ["worktree", "list", "--porcelain"]),
+	]);
+
+	if (top.code === 0 && top.out) candidates.push(path.resolve(top.out));
+
+	if (list.code === 0 && list.out) {
+		const firstRecord = list.out.split("\n\n")[0].split("\n");
+		// A bare repo is listed with a `bare` line and has no working tree to inherit.
+		const isBare = firstRecord.some((l) => l.trim() === "bare");
+		const line = firstRecord.find((l) => l.startsWith("worktree "));
+		if (!isBare && line) {
+			candidates.push(path.resolve(line.slice("worktree ".length).trim()));
+		}
+	}
+
+	// "Not a repository" is a real answer worth caching; "git never replied" is not.
+	const answered = top.code !== -1 || list.code !== -1;
+
+	// Drop this project itself and any duplicate, preserving nearest-first order.
+	const seen = new Set<string>([dir]);
+	const inheritable: string[] = [];
+	for (const candidate of candidates) {
+		if (seen.has(candidate)) continue;
+		seen.add(candidate);
+		inheritable.push(candidate);
+	}
+	return { paths: inheritable, answered };
+}

package/src/services/plugin-manager.ts

@@ -18,6 +18,7 @@ import {
 	removeFromInstalledPluginsRegistry,
 } from "./claude-settings.js";
 import { hasContentDrift } from "./content-drift.js";
+import { inheritablePaths } from "./git-worktree.js";
 import { defaultMarketplaces } from "../data/marketplaces.js";
 import type {
 	InstalledPluginsRegistry,
@@ -616,6 +617,13 @@ async function annotateContentDrift(
 		return;
 	}
 
+	// Must match how the version itself was resolved. Without this a worktree
+	// inherits an installed version but never its `gitCommitSha`, so drift
+	// detection silently switches off for exactly the plugins that just started
+	// reporting as installed.
+	const target = scope === "user" ? undefined : (projectPath ?? process.cwd());
+	const fallbackPaths = target ? await inheritablePaths(target) : [];
+
 	await Promise.all(
 		plugins.map(async (plugin) => {
 			if (plugin.hasUpdate || plugin.isOrphaned) return;
@@ -625,7 +633,8 @@ async function annotateContentDrift(
 			const entry = pickRegistryEntry(
 				registry.plugins[plugin.id],
 				scope,
-				projectPath,
+				target,
+				fallbackPaths,
 			);
 			if (!entry?.gitCommitSha) return;
 

package/src/services/resolver.ts

@@ -17,6 +17,7 @@ import type {
 	ResolvedClosure,
 } from "../types/index.js";
 import { cliTools } from "../data/cli-tools.js";
+import { getMarketplaceByName } from "../data/marketplaces.js";
 import { PREDEFINED_PROFILES } from "../data/predefined-profiles.js";
 import { resolvePluginBinRequirements } from "./plugin-requires.js";
 
@@ -147,6 +148,36 @@ async function resolveBins(
 }
 
 /** Resolve a single profile (applying `extends`) into an install closure. */
+/**
+ * Add the marketplace every plugin id already names.
+ *
+ * A plugin id carries its marketplace — `dev@magus`, `seo@magus-marketing` —
+ * so requiring the manifest to ALSO declare that marketplace is redundant, and
+ * forgetting to is silent: the plugin resolves against a marketplace that was
+ * never registered. `extends` made this the default failure, because it
+ * inherits plugins from a predefined profile and no marketplaces at all.
+ *
+ * Only marketplaces claudeup already knows are derived, since a repo is needed
+ * to register one. An unknown suffix is left alone for the manifest to declare.
+ * An explicit entry always wins: deriving must never override a pin.
+ */
+function withDerivedMarketplaces(
+	declared: ProfileManifestEntry["marketplaces"],
+	plugins: Record<string, string>,
+): NonNullable<ProfileManifestEntry["marketplaces"]> {
+	const out = { ...(declared ?? {}) };
+	for (const id of Object.keys(plugins)) {
+		const at = id.lastIndexOf("@");
+		if (at <= 0) continue;
+		const name = id.slice(at + 1);
+		if (out[name]) continue;
+		const known = getMarketplaceByName(name);
+		if (!known?.source.repo) continue;
+		out[name] = { source: "github", repo: known.source.repo };
+	}
+	return out;
+}
+
 export async function resolveProfile(
 	manifest: ProfileManifest,
 	profileId: string,
@@ -161,7 +192,7 @@ export async function resolveProfile(
 	const bins = await resolveBins(entry, Object.keys(plugins), binResolver);
 
 	return {
-		marketplaces: { ...(entry.marketplaces ?? {}) },
+		marketplaces: withDerivedMarketplaces(entry.marketplaces, plugins),
 		plugins,
 		mcpServers: { ...(entry.mcpServers ?? {}) },
 		bins,

package/src/ui/screens/PluginsScreen.tsx

@@ -6,7 +6,7 @@ import { ScreenLayout } from "../components/layout/index.js";
 import { ScrollableList } from "../components/ScrollableList.js";
 import { EmptyFilterState } from "../components/EmptyFilterState.js";
 import { fuzzyFilter } from "../../utils/fuzzy-search.js";
-import { getAllMarketplaces } from "../../data/marketplaces.js";
+import { defaultMarketplaces, getAllMarketplaces } from "../../data/marketplaces.js";
 import { clearContentDriftCache } from "../../services/content-drift.js";
 import {
 	diffVersions,
@@ -33,6 +33,7 @@ import {
 } from "../../services/claude-settings.js";
 import { saveProfile } from "../../services/profiles.js";
 import {
+	addMarketplace as cliAddMarketplace,
 	installPlugin as cliInstallPlugin,
 	repairPlugin as cliRepairPlugin,
 	uninstallPlugin as cliUninstallPlugin,
@@ -387,16 +388,60 @@ export function PluginsScreen() {
 		}
 	};
 
+	/**
+	 * Add a marketplace.
+	 *
+	 * The known ones are offered as a menu and added here — that covers every
+	 * marketplace claudeup ships with, including magus, so a first run does not
+	 * have to leave the tool. An arbitrary owner/repo still needs the terminal:
+	 * there is no text-input modal, only confirm/message/select.
+	 */
 	const handleShowAddMarketplaceInstructions = async () => {
+		const installed = new Set(
+			pluginsState.marketplaces.status === "success"
+				? pluginsState.marketplaces.data.map((m) => m.name)
+				: [],
+		);
+		const addable = defaultMarketplaces.filter(
+			(m) => !installed.has(m.name) && !m.deprecated && m.source.repo,
+		);
+
+		if (addable.length > 0) {
+			const choice = await modal.select(
+				"Add Marketplace",
+				"Pick one to add now, or choose Other for a repo not listed.",
+				[
+					...addable.map((m) => ({
+						label: m.displayName || m.name,
+						value: m.source.repo as string,
+						description: m.description,
+					})),
+					{ label: "Other…", value: "", description: "Any owner/repo" },
+				],
+			);
+			if (choice === null) return;
+			if (choice) {
+				try {
+					await cliAddMarketplace(choice);
+					await handleRefresh();
+				} catch (e) {
+					await modal.message(
+						"Could not add marketplace",
+						`${(e as Error).message}\n\nRun it yourself if this persists:\n\n` +
+							`  claude plugin marketplace add ${choice}`,
+						"error",
+					);
+				}
+				return;
+			}
+		}
+
 		await modal.message(
 			"Add Marketplace",
-			"To add a marketplace, run this command in your terminal:\n\n" +
+			"For a marketplace that is not listed, run this in your terminal:\n\n" +
 				"  claude plugin marketplace add owner/repo\n\n" +
-				"Examples:\n" +
-				"  claude plugin marketplace add MadAppGang/magus\n" +
-				"  claude plugin marketplace add anthropics/claude-plugins-official\n\n" +
 				"Auto-update is enabled by default for new marketplaces.\n\n" +
-				"After adding, refresh claudeup with 'r' to see the new marketplace.",
+				"After adding, refresh claudeup with 'r' to see it.",
 			"info",
 		);
 	};
@@ -593,14 +638,30 @@ export function PluginsScreen() {
 					);
 				}
 			} else {
-				await modal.message(
+				// Add it here rather than printing the command for the user to run.
+				// Telling someone to leave the tool, paste a command, come back and
+				// press 'r' is a step claudeup can just take: it already knows the
+				// repo, and addMarketplace() is the same call they would make.
+				const repo = mp.source.repo || mp.name;
+				const wantAdd = await modal.confirm(
 					`Add ${mp.displayName}?`,
-					`To add this marketplace, run in your terminal:\n\n` +
-						`  claude plugin marketplace add ${mp.source.repo || mp.name}\n\n` +
-						`Auto-update is enabled by default.\n\n` +
-						`After adding, refresh claudeup with 'r' to see it.`,
-					"info",
+					`Clone ${repo} and register it as a marketplace?\n\n` +
+						`Auto-update is enabled by default.`,
 				);
+				if (wantAdd) {
+					try {
+						await cliAddMarketplace(repo);
+						await handleRefresh();
+					} catch (e) {
+						await modal.message(
+							"Could not add marketplace",
+							`${(e as Error).message}\n\n` +
+								`Run it yourself if this persists:\n\n` +
+								`  claude plugin marketplace add ${repo}`,
+							"error",
+						);
+					}
+				}
 			}
 		} else if (item.kind === "plugin") {
 			const plugin = item.plugin;