magus-cli 7.12.2 → 7.14.0

package/src/cli/router.ts

@@ -28,6 +28,12 @@ export interface RouteOutcome {
 	launchTui: boolean;
 	/** From --theme, validated. Only meaningful when launchTui is true. */
 	theme?: ThemeMode;
+	/**
+	 * Which interactive app to launch when `launchTui` is true: the dependency
+	 * TUI (bare `magus`, the default) or the company marketplace screens
+	 * (`magus edit`).
+	 */
+	app?: "main" | "market";
 }
 
 export type ThemeFlagParse =
@@ -87,6 +93,21 @@ const HANDLED = (exitCode: number): RouteOutcome => ({
 });
 const LAUNCH_TUI: RouteOutcome = { handled: false, launchTui: true };
 
+/** `magus edit --help`. */
+function editHelp(): string {
+	return `magus edit — open the company marketplace screens
+
+Usage: magus edit
+
+Lists the company marketplaces on this machine, their plugins and skills, and
+creates, connects and changes them: publishes edited skills (one skill, or a
+whole plugin as one new version), and adds this project's and your USER skills
+and plugin folders to a marketplace. Needs a terminal.
+
+\`magus market --help\` lists the commands that do the same without one.
+`;
+}
+
 /**
  * Every name the switch below handles.
  *
@@ -101,6 +122,8 @@ const SUBCOMMANDS = new Set([
 	"profile",
 	"models",
 	"doctor",
+	"market",
+	"edit",
 ]);
 
 /**
@@ -122,8 +145,12 @@ export async function route(
 	 */
 	themeEnv?: ThemeEnv,
 ): Promise<RouteOutcome> {
-	// Top-level flags take precedence over any command token.
-	if (argv.includes("--version") || argv.includes("-v")) {
+	// Top-level flags take precedence over any command token — for every
+	// command but `market` and `edit`, which answer --help and --version
+	// themselves (and write nothing doing so). `magus upgrade --help` must still
+	// print help rather than upgrade, so this exception is exactly argv[0].
+	const marketFirst = argv[0] === "market" || argv[0] === "edit";
+	if (!marketFirst && (argv.includes("--version") || argv.includes("-v"))) {
 		console.log(`magus v${version}`);
 		const result = await checkForUpdates();
 		if (result.updateAvailable) {
@@ -133,7 +160,7 @@ export async function route(
 		return HANDLED(0);
 	}
 
-	if (argv.includes("--help") || argv.includes("-h")) {
+	if (!marketFirst && (argv.includes("--help") || argv.includes("-h"))) {
 		printHelp(version);
 		return HANDLED(0);
 	}
@@ -216,6 +243,32 @@ export async function route(
 				return HANDLED(await runModelsCommand(rest));
 			case "doctor":
 				return HANDLED(await runDoctorCommand(rest));
+			case "market": {
+				const { runMarketCommand } = await import("./market.js");
+				return HANDLED(await runMarketCommand(rest, version));
+			}
+			case "edit": {
+				if (rest.includes("--help") || rest.includes("-h")) {
+					console.log(editHelp());
+					return HANDLED(0);
+				}
+				if (rest.includes("--version") || rest.includes("-v")) {
+					console.log(`magus v${version}`);
+					return HANDLED(0);
+				}
+				if (rest.length > 0) {
+					console.error(
+						"magus edit: takes no arguments — the commands are `magus market <verb>` (`magus market --help` lists them)",
+					);
+					return HANDLED(2);
+				}
+				return {
+					handled: false,
+					launchTui: true,
+					app: "market",
+					...(themeFlag.theme === undefined ? {} : { theme: themeFlag.theme }),
+				};
+			}
 			default:
 				// Bare `magus` or an unrecognized token → interactive TUI.
 				return themeFlag.theme === undefined
@@ -303,6 +356,19 @@ applied by a PreToolUse hook magus registers at user scope.
   models status      What is routed now, plus any drift from the config
   models off         Stop routing; subagents inherit the session model again
 
+Company marketplaces — your team's own Claude Code plugin marketplace on
+GitHub, listed first in magus. Every change prints its plan and asks first.
+  edit               Open the company marketplace screens
+  market list        Company marketplaces on this machine, with their plugins
+  market create      Create one on GitHub;  market connect  use an existing one
+  market remove <m>  Remove one from this machine (the repository stays)
+  market plugin create|delete <p@m>;  market plugin add <path>
+  market skill add|edit|remove <skill>
+  market status      How your local copies of company skills stand
+  market publish <skill>  Send a local skill's edits back to its plugin
+  market publish --plugin <p@m>  Every edited skill of a plugin, one version
+  market --help      Every market command, its flags and exit codes
+
 Other commands:
   upgrade            Update magus ITSELF to the latest version
 

package/src/cli/update-view.ts

@@ -26,6 +26,7 @@
  * own word, so the report survives NO_COLOR, a pipe, and colour blindness.
  */
 
+import type { RegistrationResult } from "../services/marketplace-sync.js";
 import { brewUnpinCommand } from "../services/toolchain.js";
 import { binCommandFor } from "../services/update-engine.js";
 import {
@@ -935,6 +936,61 @@ export function note(text: string): string {
 	return `${PAD}   ${dim(text)}`;
 }
 
+// -- marketplace registration ------------------------------------------------
+
+/**
+ * What registering the profile's marketplaces did, for `install` and
+ * `update` alike: each marketplace added, the one-time notice for a company
+ * marketplace trusted from the profile, then each conflict and failure with
+ * its fix. Empty when nothing happened.
+ */
+export function registrationReport(result: RegistrationResult): string[] {
+	const lines: string[] = [];
+	for (const { name, source } of result.added) {
+		lines.push(ok(`${bold(name)} added to this machine ${dim(`(${source})`)}`));
+	}
+	for (const name of result.trusted) {
+		lines.push(
+			info(
+				`${bold(name)} is now a company marketplace on this machine, from this project's profile`,
+			),
+		);
+	}
+	for (const problem of [...result.conflicts, ...result.failed]) {
+		lines.push(fail(`${bold(problem.name)}: ${problem.message}`));
+		if (problem.fix) lines.push(note(problem.fix));
+	}
+	return lines;
+}
+
+/** The plugins left out of this run because their marketplace's source conflicts. */
+export function conflictSkipLine(name: string, plugins: string[]): string {
+	return warn(
+		`Left out ${plugins.map((p) => bold(p)).join(", ")} — ${name} on this machine is not the one this project's profile names`,
+	);
+}
+
+/**
+ * `magus install` stopped before activating `profile`: it turns on plugins
+ * from a marketplace whose registration here is another repository's.
+ */
+export function conflictStopLine(
+	profile: string,
+	name: string,
+	plugins: string[],
+): string {
+	return fail(
+		`Did not activate ${bold(profile)}: it turns on ${plugins.map((p) => bold(p)).join(", ")}, and ${name} on this machine is not the one this project's profile names — nothing was installed`,
+	);
+}
+
+/** A read-only run names each marketplace a real run would add, and adds none. */
+export function notRegisteredYetLine(name: string): string {
+	return info(
+		`${bold(name)} is not on this machine yet — ${bold("magus update")} adds it`,
+	);
+}
+
 // -- unverified items ----------------------------------------------------------
 //
 // A plugin is `unknown` for several distinct reasons — its marketplace publishes

package/src/cli/update.ts

@@ -39,11 +39,25 @@ import { isClaudeAvailable } from "../services/claude-cli.js";
 import { clearContentDriftCache } from "../services/content-drift.js";
 import { refusedPinWhy } from "../services/deps-plan.js";
 import { validateManifest } from "../services/manifest.js";
+import {
+	conflictFreeOptions,
+	fromConflicted,
+	leaveOutConflicted,
+} from "../services/marketplace-conflicts.js";
 import {
 	refreshRegisteredMarketplaces,
 	reportRegisteredMarketplaces,
 } from "../services/marketplace-refresh.js";
-import { registerClosureMarketplaces } from "../services/marketplace-sync.js";
+import {
+	findMarketplaceConflicts,
+	isMarketplaceRegistered,
+	registerClosureMarketplaces,
+} from "../services/marketplace-sync.js";
+import {
+	type PluginDependencyReader,
+	readPluginDependencies,
+	readUpdatedPluginDependencies,
+} from "../services/plugin-dependencies.js";
 import {
 	type PluginInfo,
 	clearMarketplaceCache,
@@ -99,14 +113,17 @@ import {
 	type Step,
 	applyFrame,
 	applyRow,
+	conflictSkipLine,
 	fail as failLine,
 	header,
 	info,
+	notRegisteredYetLine,
 	note as noteLine,
 	nothingToApplyLines,
 	ok as okLine,
 	pendingHeadline,
 	planReport,
+	registrationReport,
 	stepFrame,
 	stepRecord,
 	summaryLine,
@@ -334,7 +351,7 @@ async function updateProfile(
 	/** Notices worth keeping, flushed after the checklist collapses. */
 	const notices: string[] = [];
 
-	const closure = await runStep(steps.profile, async (say) => {
+	let closure = await runStep(steps.profile, async (say) => {
 		say(`resolving "${targetId}"`);
 		const resolved = await resolveProfile(current, targetId);
 		steps.profile.detail = [
@@ -369,14 +386,66 @@ async function updateProfile(
 	// profile's plugins, plus whatever is installed at USER scope (the refresher
 	// reads that itself). And each clone at most once an hour, machine-wide.
 	const readOnly = flags.dryRun || flags.check;
-	const pluginIds = Object.keys(closure.plugins);
+	/** Marketplaces whose registration here is not the one the profile names. */
+	const conflicted = new Set<string>();
+	/**
+	 * The conflicts a real run would report, found without registering or
+	 * trusting anything, so a run that registers nothing still leaves out the
+	 * same plugins as one that does.
+	 */
+	const detectConflicts = async () => {
+		const conflicts = await findMarketplaceConflicts(
+			closure.marketplaces,
+			projectPath,
+		);
+		notices.push(
+			...registrationReport({ added: [], trusted: [], conflicts, failed: [] }),
+		);
+		for (const c of conflicts) conflicted.add(c.name);
+	};
 	const refresh = await runStep(steps.marketplaces, async (say) => {
 		if (readOnly) {
+			await detectConflicts();
+			// Registering is a write, so a read-only run names what it would add.
+			// A conflicted one is never added, so it is not named.
+			for (const name of Object.keys(closure.marketplaces)) {
+				if (conflicted.has(name)) continue;
+				if (!(await isMarketplaceRegistered(name))) {
+					notices.push(notRegisteredYetLine(name));
+				}
+			}
 			say("read-only — selecting, not pulling");
 			// Report-only, NOT a skip: the selection is a pure read, so a read-only
 			// run can still say exactly what a real run would pull.
-			return reportRegisteredMarketplaces([], { pluginIds });
+			return reportRegisteredMarketplaces([], {
+				pluginIds: Object.keys(closure.plugins),
+			});
+		}
+		// Register what the profile names before anything is planned: without
+		// the marketplace a plugin from it is "not found", and its dependencies
+		// cannot be read. A marketplace added here holds plugin.json files the
+		// first resolve could not see, so the profile is resolved again.
+		// Without `claude` nothing can be registered; the apply phase says so.
+		if (await isClaudeAvailable()) {
+			say("registering marketplaces the profile names");
+			const registration = await registerClosureMarketplaces(
+				closure.marketplaces,
+				projectPath,
+			);
+			notices.push(...registrationReport(registration));
+			for (const c of registration.conflicts) conflicted.add(c.name);
+			if (registration.added.length > 0) {
+				clearMarketplaceCache();
+				closure = await resolveProfile(
+					current,
+					targetId,
+					conflictFreeOptions(conflicted),
+				);
+			}
+		} else {
+			await detectConflicts();
 		}
+		const pluginIds = Object.keys(closure.plugins);
 		let settled = 0;
 		return refreshRegisteredMarketplaces(
 			[],
@@ -428,6 +497,40 @@ async function updateProfile(
 	clearMarketplaceCache();
 	clearContentDriftCache();
 
+	// A pulled clone may carry a new publish that adds a dependency or a tool
+	// requirement to a plugin already listed: resolve again, so this run
+	// installs those too rather than the next one.
+	// A conflicted marketplace resolves again too: the first resolve read its
+	// plugins' dependencies and tool requirements from the other repository.
+	if (conflicted.size > 0 || (!readOnly && refresh.refreshed.length > 0)) {
+		// A plugin that follows its marketplace's latest is moved to the
+		// clone's version by this run, so its dependencies are that version's:
+		// read the clone first. A pinned plugin keeps the installed copy's.
+		const specs = closure.plugins;
+		const readDependencies: PluginDependencyReader | undefined = readOnly
+			? undefined
+			: (id, at) => {
+					const spec = specs[id];
+					return spec === undefined || spec === "latest"
+						? readUpdatedPluginDependencies(id, at)
+						: readPluginDependencies(id, at);
+				};
+		closure = await resolveProfile(
+			current,
+			targetId,
+			conflictFreeOptions(conflicted, readDependencies),
+		);
+	}
+
+	// A plugin whose marketplace here is not the profile's is left out of this
+	// run's work, with the tools only it declares: installing either would take
+	// it from the wrong repository. The same filter `magus install` uses.
+	const permitted = leaveOutConflicted(closure, conflicted);
+	closure = permitted.closure;
+	for (const l of permitted.leftOut) {
+		notices.push(conflictSkipLine(l.marketplace, l.plugins));
+	}
+
 	const catalog = await runStep(steps.catalog, async (say) => {
 		say("reading installed and available plugins");
 		const map = new Map<string, PluginInfo>(
@@ -527,11 +630,15 @@ async function updateProfile(
 		// Every profile's plugins, not only this one's: a deprecated plugin a
 		// profile that is not active lists is still a row the render keeps, and
 		// is planned for removal.
+		// The catalog lists a conflicted marketplace's installed plugins, and
+		// other profiles may list more of them: the planner leaves out every
+		// one, not only those `leaveOutConflicted` took out of the closure.
 		plugins: planPluginUpdates(
 			closure.plugins,
 			catalog,
 			requiredBy,
 			pluginsAnyProfileLists(current),
+			(pluginId) => fromConflicted(pluginId, conflicted),
 		),
 		bins: planBinUpdates(tools, toolFacts),
 		skills: planSkillUpdates(skillRefs, installedSkills),
@@ -648,11 +755,6 @@ async function updateProfile(
 		return 1;
 	}
 
-	// Register any marketplace the profile names but this machine does not know.
-	// Without this an install fails with "not found in marketplace" for anything
-	// outside magus's built-in list, which is every private or third-party one.
-	await registerClosureMarketplaces(closure.marketplaces);
-
 	// ---- apply phase, under an animated meter --------------------------------
 
 	const nameWidth = Math.max(12, ...workItems.map((n) => width(n)));

package/src/data/marketplaces.ts

@@ -249,6 +249,8 @@ export function getAllMarketplaces(
 				featured: defaultMp?.featured,
 				deprecated: defaultMp?.deprecated,
 				owned: defaultMp?.owned,
+				...(local.company ? { company: true } : {}),
+				...(local.ownerName ? { ownerName: local.ownerName } : {}),
 			});
 		}
 	}
@@ -262,9 +264,13 @@ export function getAllMarketplaces(
 		}
 	}
 
-	// Sort: Magus first, deprecated last, then alphabetically
+	// Sort: company marketplaces first, then Magus, deprecated last, then
+	// alphabetically
 	return Array.from(all.values()).sort((a, b) => {
-		// Magus (MadAppGang) always first
+		// This machine's company marketplaces lead
+		if (a.company && !b.company) return -1;
+		if (!a.company && b.company) return 1;
+		// Magus (MadAppGang) next
 		const aIsMag = a.source.repo?.toLowerCase().includes("madappgang/");
 		const bIsMag = b.source.repo?.toLowerCase().includes("madappgang/");
 		if (aIsMag && !bIsMag) return -1;

package/src/main.tsx

@@ -12,8 +12,8 @@ export const VERSION = (pkg as { version: string }).version;
 //
 // NOTHING in this file may statically import @opentui/* or ./ui/*. `magus
 // hook …` runs on every matching Claude Code tool call, and a static import
-// would load the whole TUI module graph before the hook could answer. The TUI
-// (./tui.js), the router (./cli/router.js, which reaches @opentui through
+// would load the whole TUI module graph before the hook could answer. The TUIs
+// (./tui.js and ./market-tui.js), the router (./cli/router.js, which reaches @opentui through
 // cli/update.ts → ui/theme.ts) and the hook itself are all imported on demand,
 // after the branch that decides which one is needed.
 // Pinned by __tests__/hook-import-policy.test.ts.
@@ -94,6 +94,24 @@ async function main(): Promise<void> {
 	const isInteractive =
 		process.stdin.isTTY === true && process.stdout.isTTY === true;
 
+	if (outcome.app === "market") {
+		if (!isInteractive) {
+			console.error(
+				"magus edit opens an interactive screen, which needs a terminal. `magus market --help` lists the commands that run without one.",
+			);
+			process.exit(2);
+		}
+		// The market screens, imported as late as the main TUI below and for
+		// the same reason.
+		const { startMarketTui } = await import("./market-tui.js");
+		await startMarketTui({
+			theme: outcome.theme,
+			env: themeEnv,
+			isInteractive,
+		});
+		return;
+	}
+
 	// Last possible moment: this is the import that pulls in @opentui and the
 	// whole ui/ tree. Everything above runs without them.
 	const { startTui } = await import("./tui.js");

package/src/market-tui.tsx

@@ -0,0 +1,21 @@
+/**
+ * The interactive screens behind `magus edit`: the company
+ * marketplaces on this machine, and the plugins and skills of one of them.
+ *
+ * Imported dynamically from `main.tsx`, like `tui.tsx`, so no other command
+ * loads `@opentui/*` or `src/ui/`. Opening it writes nothing; every change it
+ * makes is a plan the user confirmed, applied by the same functions the
+ * `magus market` verbs run.
+ */
+
+import { type MountTuiOptions, mountTui } from "./tui-runtime.js";
+import { MarketApp } from "./ui/market/MarketApp.js";
+
+export type StartMarketTuiOptions = MountTuiOptions;
+
+/** Start the market TUI. Never resolves — it runs until the user quits. */
+export async function startMarketTui(
+	opts: StartMarketTuiOptions,
+): Promise<void> {
+	await mountTui(opts, (quit) => <MarketApp onExit={quit} />);
+}

package/src/services/active-closure.ts

@@ -14,14 +14,25 @@
  * NOTHING HERE PRINTS — it runs under the CLI's live region and inside the TUI.
  */
 
+import { getMarketplaceByName } from "../data/marketplaces.js";
 import type {
 	ProfileManifest,
 	ResolvedClosure,
 	SelectedBin,
 } from "../types/index.js";
 import { readManifest, validateManifest } from "./manifest.js";
+import {
+	type MarketplaceCheck,
+	NOTHING_LEFT_OUT,
+	conflictFreeOptions,
+} from "./marketplace-conflicts.js";
+import { findMarketplaceConflicts } from "./marketplace-sync.js";
 import { activeProfile } from "./profile-live.js";
-import { pluginsAnyProfileLists, resolveProfile } from "./resolver.js";
+import {
+	type ResolveOptions,
+	pluginsAnyProfileLists,
+	resolveProfile,
+} from "./resolver.js";
 
 /**
  * The profile to use: the explicit one, else the active one, else the only one.
@@ -51,6 +62,13 @@ export interface ActiveClosure {
 	 * set `magus update` passes it.
 	 */
 	listedByProfiles: string[];
+	/**
+	 * The profile's marketplaces whose plugins are left out of updates here —
+	 * the same comparison `magus update` makes, read without changing
+	 * anything. When this machine's side could not be read, every marketplace
+	 * the comparison covers is `unchecked`.
+	 */
+	marketplaces: MarketplaceCheck;
 }
 
 export interface ActiveClosureDeps {
@@ -59,16 +77,19 @@ export interface ActiveClosureDeps {
 	resolveProfile(
 		manifest: ProfileManifest,
 		id: string,
-		opts?: {
-			binResolver?: (pluginId: string) => Promise<SelectedBin[]>;
-		},
+		opts?: ResolveOptions,
 	): Promise<ResolvedClosure>;
+	findMarketplaceConflicts(
+		marketplaces: ResolvedClosure["marketplaces"],
+		projectRoot?: string,
+	): Promise<Array<{ name: string }>>;
 }
 
 const REAL_DEPS: ActiveClosureDeps = {
 	readManifest,
 	activeProfile,
 	resolveProfile,
+	findMarketplaceConflicts,
 };
 
 export interface LoadActiveClosureOptions {
@@ -111,21 +132,62 @@ export async function loadActiveClosure(
 		);
 		if (profileId === null) return null;
 
-		const closure = await deps.resolveProfile(
-			manifest,
-			profileId,
-			opts.resolveBins === false ? { binResolver: NO_BINS } : {},
-		);
+		const bins: ResolveOptions =
+			opts.resolveBins === false ? { binResolver: NO_BINS } : {};
+		let closure = await deps.resolveProfile(manifest, profileId, bins);
+		const marketplaces = await checkMarketplaces(deps, closure, projectPath);
+		// A conflicted plugin's dependencies and tools were read from the other
+		// repository: resolve again without them, as `magus update` does.
+		const leftOut = new Set([
+			...marketplaces.conflicted,
+			...marketplaces.unchecked,
+		]);
+		if (leftOut.size > 0) {
+			closure = await deps.resolveProfile(manifest, profileId, {
+				...conflictFreeOptions(leftOut),
+				...bins,
+			});
+		}
 		return {
 			profileId,
 			closure,
 			listedByProfiles: pluginsAnyProfileLists(manifest),
+			marketplaces,
 		};
 	} catch {
 		return null;
 	}
 }
 
+/**
+ * Which of the closure's marketplaces differ from this machine's. A failed
+ * read is an answer too: every marketplace the comparison covers (any that is
+ * not one of magus's defaults) is then unchecked, and left out.
+ */
+async function checkMarketplaces(
+	deps: ActiveClosureDeps,
+	closure: ResolvedClosure,
+	projectPath: string,
+): Promise<MarketplaceCheck> {
+	const names = Object.keys(closure.marketplaces);
+	if (names.length === 0) return NOTHING_LEFT_OUT;
+	try {
+		const conflicts = await deps.findMarketplaceConflicts(
+			closure.marketplaces,
+			projectPath,
+		);
+		return {
+			conflicted: new Set(conflicts.map((c) => c.name)),
+			unchecked: new Set(),
+		};
+	} catch {
+		return {
+			conflicted: new Set(),
+			unchecked: new Set(names.filter((n) => !getMarketplaceByName(n))),
+		};
+	}
+}
+
 /**
  * The active profile's plugin pins — `pluginId -> exact version | "latest"` — and
  * `{}` when no profile resolves.