claudeup 4.42.1 → 5.0.0

package/src/services/marketplace-sync.ts

@@ -1,3 +1,5 @@
+import os from "node:os";
+import path from "node:path";
 /**
  * Marketplace sync service
  *
@@ -13,17 +15,16 @@
  * deleted. See ai-docs/plugin-marketplace-bug-investigation.md.
  */
 import fs from "fs-extra";
-import path from "node:path";
-import os from "node:os";
+import { defaultMarketplaces } from "../data/marketplaces.js";
+import type { ProfileMarketplaceRef } from "../types/index.js";
+import { parsePluginId } from "../utils/string-utils.js";
+import { addMarketplace } from "./claude-cli.js";
 import {
-	getGlobalEnabledPlugins,
 	getEnabledPlugins,
+	getGlobalEnabledPlugins,
 	getLocalEnabledPlugins,
 	isMarketplaceRegistered,
 } from "./claude-settings.js";
-import { parsePluginId } from "../utils/string-utils.js";
-import { defaultMarketplaces } from "../data/marketplaces.js";
-import { addMarketplace } from "./claude-cli.js";
 
 const MARKETPLACES_DIR = path.join(
 	os.homedir(),
@@ -77,6 +78,36 @@ export async function getReferencedMarketplaces(
 /** Re-exported for convenience — canonical implementation lives in claude-settings. */
 export { isMarketplaceRegistered };
 
+/**
+ * Register every marketplace a resolved profile closure declares, skipping any
+ * already known.
+ *
+ * Shared by `install` and `update`. It lived inside cli/install.ts until
+ * `update` shipped without it and could not install a plugin from a marketplace
+ * this machine had never registered: `installPlugin`'s own recovery path only
+ * knows claudeup's built-in `defaultMarketplaces`, so a manifest naming a
+ * private or third-party marketplace failed with "not found in marketplace" and
+ * no way forward.
+ *
+ * Failures are warned about, never thrown — one unreachable marketplace must not
+ * abort the whole run.
+ */
+export async function registerClosureMarketplaces(
+	marketplaces: Record<string, ProfileMarketplaceRef>,
+): Promise<void> {
+	for (const [name, ref] of Object.entries(marketplaces)) {
+		try {
+			if (await isMarketplaceRegistered(name)) continue;
+			const source = ref.source === "github" ? ref.repo : ref.path;
+			if (!source) continue;
+			console.log(`+ marketplace ${name} (${source})`);
+			await addMarketplace(source);
+		} catch (e) {
+			console.warn(`⚠ marketplace ${name}: ${(e as Error).message}`);
+		}
+	}
+}
+
 /**
  * Register any referenced marketplaces that are missing locally.
  * Looks up the GitHub repo in `defaultMarketplaces` and calls

package/src/services/plugin-manager.ts

@@ -13,9 +13,12 @@ import {
 	getProjectInstalledPluginVersions,
 	pickRegistryEntry,
 	readInstalledPluginsRegistry,
+	saveGlobalInstalledPluginVersion,
+	saveLocalInstalledPluginVersion,
 	updateInstalledPluginsRegistry,
 	removeFromInstalledPluginsRegistry,
 } from "./claude-settings.js";
+import type { PluginScope } from "./claude-cli.js";
 import { hasContentDrift } from "./content-drift.js";
 import { inheritablePaths } from "./git-worktree.js";
 import { defaultMarketplaces } from "../data/marketplaces.js";
@@ -800,6 +803,53 @@ export async function saveInstalledPluginVersion(
 	);
 }
 
+/**
+ * The version Claude Code's own registry records for a plugin at a scope, read
+ * fresh from disk.
+ *
+ * Exists because `claude plugin install` takes NO version argument — it installs
+ * whatever the marketplace currently publishes. The version we asked for and the
+ * version we got are therefore different questions, and only this one can answer
+ * the second. Callers must record what this returns, never what they intended:
+ * writing the intent fabricates state that the drift gate then trusts.
+ */
+export async function readInstalledVersionForScope(
+	pluginId: string,
+	scope: PluginScope,
+	projectPath: string = process.cwd(),
+): Promise<string | null> {
+	const registry = await readInstalledPluginsRegistry();
+	const entry = pickRegistryEntry(
+		registry.plugins?.[pluginId],
+		scope,
+		projectPath,
+	);
+	return entry?.version ?? null;
+}
+
+/**
+ * Record an installed version in the settings file that owns the given scope.
+ *
+ * Claude Code's CLI does not maintain `installedPluginVersions`, so claudeup
+ * keeps its own copy. Writing it at the WRONG scope is worse than not writing
+ * it: it makes a scope claim a version it does not have installed. Writing the
+ * wrong VERSION is worse still — see {@link readInstalledVersionForScope}.
+ */
+export async function saveInstalledPluginVersionForScope(
+	pluginId: string,
+	version: string,
+	scope: PluginScope,
+	projectPath: string = process.cwd(),
+): Promise<void> {
+	if (scope === "user") {
+		await saveGlobalInstalledPluginVersion(pluginId, version);
+	} else if (scope === "local") {
+		await saveLocalInstalledPluginVersion(pluginId, version, projectPath);
+	} else {
+		await saveInstalledPluginVersion(pluginId, version, projectPath);
+	}
+}
+
 // Remove installed plugin version from settings.json
 export async function removeInstalledPluginVersion(
 	pluginId: string,

package/src/services/profile-adopt.ts

@@ -0,0 +1,206 @@
+/**
+ * Adopt a project into profile management.
+ *
+ * `install` and `update` both speak the language of `.claude/profiles.json`,
+ * and most repos do not have one. The answer is to write one from what the
+ * project already has — enabled plugins, MCP servers, settings — rather than
+ * to run a second, manifest-free code path beside it. One command shape, one
+ * source of truth, and the generated file is a reviewable diff the user can
+ * commit and hand to the rest of the team.
+ *
+ * Plugins are adopted as "latest", never as the version that happens to be
+ * installed today. Pinning what a machine drifted to would turn one developer's
+ * accident into the team's contract.
+ */
+
+import type {
+	McpServerConfig,
+	ProfileManifest,
+	ProfileManifestEntry,
+} from "../types/index.js";
+import {
+	getEnabledPlugins,
+	getGlobalEnabledPlugins,
+	readMcpConfig,
+	readSettings,
+} from "./claude-settings.js";
+import { emptyManifest } from "./manifest.js";
+import { withDerivedMarketplaces } from "./resolver.js";
+
+/** The profile id used when adopting a project that has no manifest. */
+export const ADOPTED_PROFILE_ID = "default";
+
+export interface AdoptInput {
+	/** Union of enabled plugins across every scope: id -> enabled. */
+	enabledPlugins: Record<string, boolean>;
+	/** Project `.claude/settings.json`, verbatim. */
+	settings: Record<string, unknown>;
+	/** Project `.mcp.json` servers. */
+	mcpServers: Record<string, McpServerConfig>;
+	/** Display name for the generated profile. */
+	name?: string;
+	/** Injectable clock so the output is deterministic in tests. */
+	now?: string;
+}
+
+/**
+ * Build a manifest entry from captured project state. Pure.
+ *
+ * `enabledPlugins` is dropped from `settings` deliberately: it is expressed as
+ * the entry's `plugins` map, and materialization regenerates it. Carrying both
+ * would let them disagree.
+ */
+/**
+ * Settings keys that describe THIS MACHINE, not the project, and must never be
+ * copied into a manifest meant to be committed.
+ *
+ * - `enabledPlugins` is expressed as the entry's `plugins` map and regenerated
+ *   by materialization; carrying both lets them disagree.
+ * - `installedPluginVersions` is claudeup's private record of what this machine
+ *   has on disk. Committing it publishes one developer's install state as if it
+ *   were the team's contract, and it goes stale the moment anyone updates.
+ */
+const MACHINE_ONLY_SETTINGS_KEYS = [
+	"enabledPlugins",
+	"installedPluginVersions",
+] as const;
+
+/**
+ * Settings values that mention an absolute path under the user's home
+ * directory. Not stripped — a `permissions.additionalDirectories` list is often
+ * genuinely wanted — but surfaced so the user reviews them before committing.
+ */
+export function findMachineSpecificPaths(
+	settings: Record<string, unknown>,
+	home: string = process.env.HOME ?? "",
+): string[] {
+	if (!home) return [];
+	const hits: string[] = [];
+	const walk = (value: unknown, path: string): void => {
+		if (typeof value === "string") {
+			if (value.includes(home)) hits.push(`${path} = ${value}`);
+			return;
+		}
+		if (Array.isArray(value)) {
+			value.forEach((v, i) => walk(v, `${path}[${i}]`));
+			return;
+		}
+		if (value && typeof value === "object") {
+			for (const [k, v] of Object.entries(value)) walk(v, `${path}.${k}`);
+		}
+	};
+	for (const [k, v] of Object.entries(settings)) walk(v, k);
+	return hits;
+}
+
+export function buildAdoptedProfile(input: AdoptInput): ProfileManifestEntry {
+	const plugins: Record<string, string> = {};
+	for (const [id, enabled] of Object.entries(input.enabledPlugins)) {
+		// A plugin id must name its marketplace; anything else cannot be resolved
+		// or reinstalled on another machine, so it has no place in a team manifest.
+		if (enabled && id.includes("@")) plugins[id] = "latest";
+	}
+
+	const settings = { ...input.settings };
+	for (const key of MACHINE_ONLY_SETTINGS_KEYS) delete settings[key];
+
+	const entry: ProfileManifestEntry = {
+		name: input.name ?? "Default",
+		marketplaces: withDerivedMarketplaces(undefined, plugins),
+		plugins,
+		createdAt: input.now ?? new Date().toISOString(),
+	};
+	if (Object.keys(input.mcpServers).length > 0) {
+		entry.mcpServers = input.mcpServers;
+	}
+	if (Object.keys(settings).length > 0) entry.settings = settings;
+	return entry;
+}
+
+export interface AdoptResult {
+	manifest: ProfileManifest;
+	profileId: string;
+	entry: ProfileManifestEntry;
+	counts: { plugins: number; mcpServers: number; settingsKeys: number };
+	/** Which settings file the plugin list came from. */
+	source: AdoptSource;
+	/** Enabled plugin ids skipped because they name no marketplace. */
+	skipped: string[];
+	/** Carried-over settings values naming an absolute path under $HOME. */
+	machinePaths: string[];
+}
+
+/** Which settings file the adopted plugin list came from. */
+export type AdoptSource = "project" | "user";
+
+/**
+ * Find the plugins to adopt, preferring PROJECT scope.
+ *
+ * The generated manifest is meant to be committed, so its plugin list must
+ * describe the repo, not the machine. `.claude/settings.json` is exactly that:
+ * the repo's own committed choice. User scope (`~/.claude/settings.json`) is
+ * one developer's global set and local scope is gitignored personal state —
+ * adopting either silently would publish a personal setup as the team's
+ * contract.
+ *
+ * User scope is still offered as a fallback, because a developer who enables
+ * everything globally would otherwise have nothing to adopt. The caller is told
+ * which source was used and says so, so the choice is never invisible.
+ */
+async function collectEnabledPlugins(
+	projectPath: string,
+): Promise<{ plugins: Record<string, boolean>; source: AdoptSource }> {
+	const project = await getEnabledPlugins(projectPath).catch(() => ({}));
+	if (Object.values(project).some(Boolean)) {
+		return { plugins: project, source: "project" };
+	}
+	const user = await getGlobalEnabledPlugins().catch(() => ({}));
+	return { plugins: user, source: "user" };
+}
+
+/**
+ * Read this project's current state and produce the manifest that describes it.
+ * Does not write — the caller confirms first.
+ */
+export async function adoptCurrentProject(
+	projectPath: string,
+	name?: string,
+): Promise<AdoptResult> {
+	const { plugins: enabledPlugins, source } =
+		await collectEnabledPlugins(projectPath);
+	const settings = (await readSettings(projectPath)) as unknown as Record<
+		string,
+		unknown
+	>;
+	const mcp = await readMcpConfig(projectPath);
+
+	const entry = buildAdoptedProfile({
+		enabledPlugins,
+		settings,
+		mcpServers: mcp.mcpServers ?? {},
+		name,
+	});
+
+	const manifest = emptyManifest();
+	manifest.profiles[ADOPTED_PROFILE_ID] = entry;
+
+	const skipped = Object.entries(enabledPlugins)
+		.filter(([id, on]) => on && !id.includes("@"))
+		.map(([id]) => id);
+
+	return {
+		manifest,
+		profileId: ADOPTED_PROFILE_ID,
+		entry,
+		source,
+		counts: {
+			plugins: Object.keys(entry.plugins ?? {}).length,
+			mcpServers: Object.keys(entry.mcpServers ?? {}).length,
+			settingsKeys: Object.keys(entry.settings ?? {}).length,
+		},
+		skipped,
+		machinePaths: findMachineSpecificPaths(
+			(entry.settings ?? {}) as Record<string, unknown>,
+		),
+	};
+}

package/src/services/resolver.ts

@@ -161,7 +161,7 @@ async function resolveBins(
  * 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(
+export function withDerivedMarketplaces(
 	declared: ProfileManifestEntry["marketplaces"],
 	plugins: Record<string, string>,
 ): NonNullable<ProfileManifestEntry["marketplaces"]> {

package/src/services/toolchain.ts

@@ -95,3 +95,38 @@ export function binInstallCommand(bin: {
 			return `go install ${bin.module ?? bin.name}@${bin.version ?? "latest"}`;
 	}
 }
+
+/**
+ * The command that advances an ALREADY-INSTALLED binary to the newest version.
+ *
+ * Distinct from {@link binInstallCommand} because two of the five installers
+ * treat "install" as a no-op once the package is present: `brew install` on an
+ * installed formula prints "already installed" and changes nothing, and `pip
+ * install` without `--upgrade` does the same. Reusing the install command for
+ * `claudeup update` would therefore report success while advancing nothing.
+ *
+ * A pinned version has nothing to advance to, so callers must only reach this
+ * for unpinned requirements; `@latest` is stated explicitly where the installer
+ * accepts it, so the intent survives in the printed command.
+ */
+export function binUpgradeCommand(bin: {
+	name: string;
+	via: BinInstaller;
+	package?: string;
+	formula?: string;
+	module?: string;
+}): string {
+	const pkg = bin.package ?? bin.name;
+	switch (bin.via) {
+		case "bun":
+			return `bun install -g ${pkg}@latest`;
+		case "npm":
+			return `npm install -g ${pkg}@latest`;
+		case "pip":
+			return `pip install --upgrade ${pkg}`;
+		case "brew":
+			return `brew upgrade ${bin.formula ?? bin.name}`;
+		case "go":
+			return `go install ${bin.module ?? bin.name}@latest`;
+	}
+}