claudeup 6.5.1 → 6.7.1

package/src/cli/claude.ts

@@ -1,21 +0,0 @@
-/**
- * `claudeup claude [args...]` — prerunner mode.
- *
- * Runs plugin/marketplace update & migration checks (1h cache, or `-f`/`--force`
- * to bypass), then execs `claude` with the remaining args. Returns claude's exit
- * code so the caller can propagate it.
- */
-
-import { prerunClaude } from "../prerunner/index.js";
-
-export async function runClaudeCommand(claudeArgs: string[]): Promise<number> {
-	const forceUpdate =
-		claudeArgs.includes("--force") || claudeArgs.includes("-f");
-
-	// Remove prerunner-specific flags before passing args to claude.
-	const filteredArgs = claudeArgs.filter(
-		(arg) => arg !== "--force" && arg !== "-f",
-	);
-
-	return prerunClaude(filteredArgs, { force: forceUpdate });
-}

package/src/prerunner/index.ts

@@ -1,500 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-import fs from "fs-extra";
-import {
-	type PluginScope,
-	isClaudeAvailable,
-	repairPlugin,
-	updatePlugin,
-} from "../services/claude-cli.js";
-import { runClaude } from "../services/claude-runner.js";
-import {
-	cleanupExtraKnownMarketplaces,
-	gapFillInstalledPluginVersions,
-	migrateMarketplaceRename,
-	readGlobalSettings,
-	recoverMarketplaceSettings,
-	saveGlobalInstalledPluginVersion,
-	saveLocalInstalledPluginVersion,
-	writeGlobalSettings,
-} from "../services/claude-settings.js";
-import { clearContentDriftCache } from "../services/content-drift.js";
-import {
-	checkGitignore,
-	formatPrerunWarning as formatGitignoreWarning,
-} from "../services/gitignore-prerun.js";
-import { refreshRegisteredMarketplaces } from "../services/marketplace-refresh.js";
-import { autoAddMissingMarketplaces } from "../services/marketplace-sync.js";
-import {
-	clearMarketplaceCache,
-	compareVersions,
-	getAvailablePlugins,
-	saveInstalledPluginVersionForScope,
-} from "../services/plugin-manager.js";
-import {
-	checkPluginVersionMismatches,
-	formatMismatchWarning,
-} from "../services/plugin-version-check.js";
-import { UpdateCache } from "../services/update-cache.js";
-
-export interface PrerunOptions {
-	force?: boolean; // Bypass cache and force update check
-}
-
-const CONTINUITY_PLUGIN_SENTINEL = "tmux-claude-continuity";
-const CONTINUITY_PLUGIN_SCRIPT = path.join(
-	os.homedir(),
-	".tmux",
-	"plugins",
-	"tmux-claude-continuity",
-	"scripts",
-	"on_session_start.sh",
-);
-
-/**
- * Ensure tmux-claude-continuity Claude Code hooks are present in global settings.
- * If the tmux plugin is installed but the hooks are missing, they are appended.
- * Returns a description of what was added, or null if nothing changed.
- */
-async function ensureTmuxContinuityHooks(): Promise<string | null> {
-	// Plugin not installed — nothing to do
-	if (!(await fs.pathExists(CONTINUITY_PLUGIN_SCRIPT))) {
-		return null;
-	}
-
-	const settings = await readGlobalSettings();
-
-	// Check if hooks are already configured by looking for the sentinel string
-	const existingHooks = settings.hooks ?? {};
-	for (const groups of Object.values(existingHooks)) {
-		for (const group of groups) {
-			for (const hook of group.hooks) {
-				if (hook.command.includes(CONTINUITY_PLUGIN_SENTINEL)) {
-					return null; // Already configured
-				}
-			}
-		}
-	}
-
-	// Append hooks, preserving any existing entries in SessionStart and Stop
-	const sessionStartGroups = existingHooks.SessionStart ?? [];
-	const stopGroups = existingHooks.Stop ?? [];
-
-	sessionStartGroups.push({
-		hooks: [
-			{
-				type: "command",
-				command:
-					"bash ~/.tmux/plugins/tmux-claude-continuity/scripts/on_session_start.sh",
-			},
-		],
-	});
-
-	stopGroups.push({
-		hooks: [
-			{
-				type: "command",
-				command:
-					"bash ~/.tmux/plugins/tmux-claude-continuity/scripts/on_stop.sh",
-			},
-		],
-	});
-
-	settings.hooks = {
-		...existingHooks,
-		SessionStart: sessionStartGroups,
-		Stop: stopGroups,
-	};
-
-	await writeGlobalSettings(settings);
-	return "SessionStart + Stop hooks";
-}
-
-/**
- * Prerun orchestration: Check for updates, apply them, then run claude
- * @param claudeArgs - Arguments to pass to claude CLI
- * @param options - Prerun options (force, etc.)
- * @returns Exit code from claude process
- */
-export async function prerunClaude(
-	claudeArgs: string[],
-	options: PrerunOptions = {},
-): Promise<number> {
-	const cache = new UpdateCache();
-
-	try {
-		// STEP 0: Migrate old marketplace names → magus (idempotent, no-ops if already migrated)
-		const migration = await migrateMarketplaceRename();
-		const migTotal =
-			migration.projectMigrated +
-			migration.globalMigrated +
-			migration.localMigrated +
-			migration.registryMigrated +
-			(migration.knownMarketplacesMigrated ? 1 : 0);
-		if (migTotal > 0) {
-			console.log(`✓ Migrated ${migTotal} plugin reference(s) → magus`);
-		}
-
-		// STEP 0.5: Auto-add missing marketplaces
-		// When plugins reference a marketplace that's not installed locally
-		// (e.g., settings synced from another machine or committed by a
-		// teammate in .claude/settings.json), add it automatically. Pass
-		// process.cwd() so project and local enabledPlugins are scanned —
-		// otherwise a freshly cloned repo whose only @magus references live
-		// in project settings looks "clean" from the global-scope view.
-		if (await isClaudeAvailable()) {
-			const addedMarketplaces = await autoAddMissingMarketplaces(process.cwd());
-			if (addedMarketplaces.length > 0) {
-				console.log(
-					`✓ Auto-added marketplace(s): ${addedMarketplaces.join(", ")}`,
-				);
-			}
-		}
-
-		// STEP 0.55: Clean up extraKnownMarketplaces entries that are now in known_marketplaces.json
-		// extraKnownMarketplaces was the old install mechanism; the official way is known_marketplaces.json
-		try {
-			const cleaned = await cleanupExtraKnownMarketplaces();
-			if (cleaned.length > 0) {
-				console.log(
-					`✓ Cleaned up legacy extraKnownMarketplaces: ${cleaned.join(", ")}`,
-				);
-			}
-		} catch {
-			// Non-fatal: cleanup is best-effort
-		}
-
-		// STEP 0.6: Ensure tmux-claude-continuity hooks are configured
-		const addedHooks = await ensureTmuxContinuityHooks();
-		if (addedHooks) {
-			console.log(
-				"✓ Added tmux-claude-continuity hooks to ~/.claude/settings.json",
-			);
-		}
-
-		// STEP 0.7: Gap-fill installedPluginVersions across scopes
-		// When a plugin is updated at project/local scope, global may lag behind.
-		// Sync the highest version from any scope up to global so Claude Code
-		// resolves the latest cached plugin paths at session startup.
-		try {
-			const gapFilled = await gapFillInstalledPluginVersions(process.cwd());
-			if (gapFilled.length > 0) {
-				console.log(
-					`✓ Synced ${gapFilled.length} plugin version(s) to global:`,
-				);
-				for (const { pluginId, oldVersion, newVersion } of gapFilled) {
-					console.log(`  - ${pluginId}: ${oldVersion} → ${newVersion}`);
-				}
-			}
-		} catch {
-			// Non-fatal: gap-fill is best-effort
-		}
-
-		// STEP 0.8: Detect plugin version mismatches caused by the [0] index bug
-		// Claude Code's pluginLoader.ts takes entries[0] regardless of project,
-		// so if another project installed a different version first, this project
-		// will silently load the wrong version.
-		try {
-			const cwd = process.cwd();
-			const mismatches = await checkPluginVersionMismatches(cwd);
-			if (mismatches.length > 0) {
-				console.warn("");
-				console.warn(formatMismatchWarning(mismatches));
-				console.warn("");
-			}
-		} catch {
-			// Non-fatal: mismatch detection is best-effort
-		}
-
-		// STEP 0.9: Detect gitignore manifest violations. Warn-only here — the
-		// fix dialog lives in the TUI Gitignore tab, mirroring the plugin
-		// version-mismatch flow (since destructive fixes need user confirmation).
-		try {
-			const cwd = process.cwd();
-			const result = await checkGitignore(cwd);
-			const warning = formatGitignoreWarning(result);
-			if (warning) {
-				console.warn("");
-				console.warn(warning);
-				console.warn("");
-			}
-		} catch {
-			// Non-fatal: gitignore detection is best-effort
-		}
-
-		// STEP 1: Check if we should update (time-based cache, or forced)
-		const shouldUpdate = options.force || (await cache.shouldCheckForUpdates());
-
-		if (options.force) {
-			console.log("⟳ Forcing plugin update check...");
-		}
-
-		if (shouldUpdate) {
-			// STEP 1.5: Recover marketplace settings (enable autoUpdate, remove stale entries)
-			const recovery = await recoverMarketplaceSettings();
-			if (recovery.enabledAutoUpdate.length > 0) {
-				console.log(
-					`✓ Enabled auto-update for: ${recovery.enabledAutoUpdate.join(", ")}`,
-				);
-			}
-			if (recovery.removed.length > 0) {
-				console.log(
-					`✓ Removed stale marketplaces: ${recovery.removed.join(", ")}`,
-				);
-			}
-			if (recovery.reregistered.length > 0) {
-				console.log(
-					`✓ Re-registered as GitHub source: ${recovery.reregistered.join(", ")}`,
-				);
-				// Re-registration only rewrites known_marketplaces.json (directory →
-				// github source); it does NOT create the on-disk clone. Clone any whose
-				// directory is missing, using the NON-DESTRUCTIVE `marketplace add` —
-				// never `marketplace update`, which deletes the directory before
-				// re-cloning and can leave it permanently gone on failure (see
-				// marketplace-refresh.ts / marketplace-sync.ts). Clones that already
-				// exist are left to STEP 1.7's safe `git pull --ff-only`.
-				const cliAvailable = await isClaudeAvailable();
-				if (cliAvailable) {
-					const { addMarketplace } = await import("../services/claude-cli.js");
-					const { defaultMarketplaces } = await import(
-						"../data/marketplaces.js"
-					);
-					const marketplacesDir = path.join(
-						os.homedir(),
-						".claude",
-						"plugins",
-						"marketplaces",
-					);
-					for (const mpName of recovery.reregistered) {
-						// Already on disk → STEP 1.7 fast-forwards it; nothing to clone.
-						if (await fs.pathExists(path.join(marketplacesDir, mpName))) {
-							continue;
-						}
-						const repo = defaultMarketplaces.find((m) => m.name === mpName)
-							?.source.repo;
-						if (!repo) continue;
-						try {
-							await addMarketplace(repo);
-							console.log(`✓ Cloned re-registered marketplace: ${mpName}`);
-						} catch (error) {
-							console.warn(
-								`⚠ Failed to clone marketplace ${mpName}:`,
-								error instanceof Error ? error.message : "Unknown error",
-							);
-						}
-					}
-				}
-			}
-
-			// STEP 1.7: Fast-forward the on-disk clones of every registered
-			// marketplace. Recovery above only *clones* re-registered ones that were
-			// missing; nothing else advances an existing healthy clone, so updated
-			// plugin setup metadata — e.g. a pinned dependency version — is never seen
-			// even though the fetched plugin list is current. Non-destructive
-			// `git pull --ff-only`: a failed pull leaves the clone stale, never gone.
-			const mpRefresh = await refreshRegisteredMarketplaces();
-			if (mpRefresh.refreshed.length > 0) {
-				console.log(
-					`✓ Refreshed marketplaces: ${mpRefresh.refreshed.join(", ")}`,
-				);
-			}
-			if (mpRefresh.autoUpdateDisabled.length > 0) {
-				// Silence here is what let a clone sit 11 days behind: the catalog
-				// stops moving, so every plugin from that marketplace reads as up
-				// to date and no update is ever offered.
-				for (const name of mpRefresh.autoUpdateDisabled) {
-					console.log(
-						`⚠ ${name}: auto-update disabled — its plugin catalog will not refresh, so updates stay hidden.`,
-					);
-				}
-				console.log(
-					`  Re-enable with: claude plugin marketplace update ${mpRefresh.autoUpdateDisabled[0]}  (or set autoUpdate:true in ~/.claude/plugins/known_marketplaces.json)`,
-				);
-			}
-			for (const name of mpRefresh.failed) {
-				console.warn(`⚠ Failed to refresh marketplace: ${name}`);
-			}
-
-			// STEP 2: Clear cache to force fresh plugin info
-			clearMarketplaceCache();
-			// The marketplace refresh above may have moved each clone's HEAD, and
-			// drift answers are relative to HEAD.
-			clearContentDriftCache();
-
-			// STEP 3: Get updated plugin info (to detect versions)
-			const plugins = await getAvailablePlugins();
-
-			// STEP 4: Auto-update enabled plugins via claude CLI
-			const autoUpdatedPlugins: Array<{
-				pluginId: string;
-				oldVersion: string;
-				newVersion: string;
-				/** Scopes actually updated — never assume "user". */
-				scopes: ReadonlyArray<PluginScope>;
-			}> = [];
-			/** Plugins whose files drifted under an unchanged version. */
-			const repairedPlugins: Array<{
-				pluginId: string;
-				scope: PluginScope;
-			}> = [];
-
-			const cliAvailable = await isClaudeAvailable();
-
-			for (const plugin of plugins) {
-				// Only update if:
-				// 1. Plugin is enabled
-				// 2. Plugin has an update available
-				// 3. Plugin has both installedVersion and version (newVersion)
-				// A content-stale plugin has NO version bump to detect — its files
-				// changed under an unchanged version — so it must be repaired
-				// (uninstall+install) rather than updated. Auto-fixing broken state
-				// without human interaction is claudeup's job; leaving a plugin
-				// silently running deleted skills is exactly the state it exists
-				// to prevent.
-				if (
-					plugin.enabled &&
-					!plugin.hasUpdate &&
-					plugin.contentStale &&
-					plugin.installedVersion
-				) {
-					if (!cliAvailable) continue;
-					const staleScopes = (
-						[
-							["user", plugin.userScope],
-							["project", plugin.projectScope],
-							["local", plugin.localScope],
-						] as const
-					)
-						.filter(([, status]) => !!status?.version)
-						.map(([scope]) => scope);
-
-					for (const scope of staleScopes) {
-						try {
-							await repairPlugin(plugin.id, scope, process.cwd());
-							repairedPlugins.push({ pluginId: plugin.id, scope });
-						} catch (error) {
-							console.warn(
-								`⚠ Failed to repair ${plugin.id} (${scope}):`,
-								error instanceof Error ? error.message : "Unknown error",
-							);
-						}
-					}
-					continue;
-				}
-
-				if (
-					plugin.enabled &&
-					plugin.hasUpdate &&
-					plugin.installedVersion &&
-					plugin.version
-				) {
-					try {
-						if (!cliAvailable) {
-							// CLI unavailable — skip update entirely, don't write phantom state
-							continue;
-						}
-
-						// Update every scope that actually holds an outdated install.
-						//
-						// This used to be a hardcoded `updatePlugin(plugin.id, "user")`,
-						// which was wrong for almost every real install: `hasUpdate` is
-						// computed from the CURRENT PROJECT's resolved version, while
-						// installs live per project in installed_plugins.json. On this
-						// machine 495 of 496 magus installs are project-scoped, so the
-						// prerunner detected project drift, "fixed" it at user scope,
-						// reported success — and left the project row untouched. Next run
-						// it detected the same drift again. The update never converged,
-						// which is what "auto-update ran but an update is still available"
-						// actually was.
-						const outdatedScopes = (
-							[
-								["user", plugin.userScope],
-								["project", plugin.projectScope],
-								["local", plugin.localScope],
-							] as const
-						)
-							.filter(
-								([, status]) =>
-									!!status?.version &&
-									compareVersions(plugin.version, status.version) > 0,
-							)
-							.map(([scope]) => scope);
-
-						if (outdatedScopes.length === 0) continue;
-
-						for (const scope of outdatedScopes) {
-							await updatePlugin(plugin.id, scope);
-							// The CLI does not maintain installedPluginVersions, so keep
-							// claudeup's own copy in step for the scope we just touched.
-							await saveInstalledPluginVersionForScope(
-								plugin.id,
-								plugin.version,
-								scope,
-							);
-						}
-
-						autoUpdatedPlugins.push({
-							pluginId: plugin.id,
-							oldVersion: plugin.installedVersion,
-							newVersion: plugin.version,
-							scopes: outdatedScopes,
-						});
-					} catch (error) {
-						// Non-fatal: Log warning and continue
-						console.warn(
-							`⚠ Failed to auto-update ${plugin.id}:`,
-							error instanceof Error ? error.message : "Unknown error",
-						);
-					}
-				}
-			}
-
-			// STEP 5: Save cache
-			await cache.saveCheck({
-				lastUpdateCheck: new Date().toISOString(),
-				lastUpdateResult: {
-					updated: [],
-					failed: [],
-					autoUpdated: autoUpdatedPlugins,
-				},
-			});
-
-			// STEP 6: Display auto-update summary
-			if (autoUpdatedPlugins.length > 0) {
-				console.log(`✓ Auto-updated ${autoUpdatedPlugins.length} plugin(s):`);
-				for (const {
-					pluginId,
-					oldVersion,
-					newVersion,
-					scopes,
-				} of autoUpdatedPlugins) {
-					// Name the scope. "Auto-updated" that silently touched only user
-					// scope, while the project stayed behind, is exactly how this became
-					// untrustworthy.
-					console.log(
-						`  - ${pluginId}: ${oldVersion} → ${newVersion} (${scopes.join(", ")})`,
-					);
-				}
-			}
-
-			if (repairedPlugins.length > 0) {
-				console.log(
-					`✓ Repaired ${repairedPlugins.length} plugin(s) whose files changed without a version bump:`,
-				);
-				for (const { pluginId, scope } of repairedPlugins) {
-					console.log(`  - ${pluginId} (${scope})`);
-				}
-			}
-		}
-		// If !shouldUpdate → silent (no output)
-	} catch (error) {
-		// Non-fatal errors - warn and continue
-		console.warn(
-			"Warning: Plugin update check failed:",
-			error instanceof Error ? error.message : "Unknown error",
-		);
-	}
-
-	// STEP 8: Always run claude (even if update failed)
-	return runClaude(claudeArgs);
-}