claudeup 4.1.0 → 4.3.0

package/src/ui/screens/CliToolsScreen.tsx

@@ -1,5 +1,5 @@
 import React, { useEffect, useCallback, useState, useRef } from "react";
-import { exec, execSync } from "child_process";
+import { exec } from "child_process";
 import { promisify } from "util";
 import { useApp, useModal } from "../state/AppContext.js";
 import { useDimensions } from "../state/DimensionsContext.js";
@@ -11,6 +11,7 @@ import {
 	renderCliToolRow,
 	renderCliToolDetail,
 	type CliToolStatus,
+	type InstallMethod,
 } from "../renderers/cliToolRenderers.js";
 
 const execAsync = promisify(exec);
@@ -31,19 +32,105 @@ function parseVersion(versionOutput: string): string | undefined {
 	return match ? match[1] : undefined;
 }
 
-async function isInstalledViaHomebrew(toolName: string): Promise<boolean> {
+function methodFromPath(binPath: string): InstallMethod | null {
+	if (binPath.includes("/.bun/")) return "bun";
+	if (binPath.includes("/homebrew/") || binPath.includes("/Cellar/")) return "brew";
+	if (binPath.includes("/.local/share/claude") || binPath.includes("/.local/bin/claude")) return "npm";
+	if (binPath.includes("/.nvm/") || binPath.includes("/node_modules/")) return "npm";
+	if (binPath.includes("/.local/share/pnpm") || binPath.includes("/pnpm/")) return "pnpm";
+	if (binPath.includes("/.yarn/")) return "yarn";
+	return null;
+}
+
+interface InstallInfo {
+	primary: InstallMethod;
+	all: InstallMethod[];
+	brewFormula?: string;
+}
+
+/** Extract brew formula name from a Cellar symlink target like ../Cellar/gemini-cli/0.35.2/bin/gemini */
+function extractBrewFormula(binPath: string, linkTarget: string): string | undefined {
+	// Try symlink target first: ../Cellar/{formula}/{version}/...
+	const cellarMatch = linkTarget.match(/Cellar\/([^/]+)\//);
+	if (cellarMatch) return cellarMatch[1];
+	// Try binary path: /opt/homebrew/Cellar/{formula}/...
+	const pathMatch = binPath.match(/Cellar\/([^/]+)\//);
+	if (pathMatch) return pathMatch[1];
+	return undefined;
+}
+
+async function detectInstallMethods(
+	tool: import("../../data/cli-tools.js").CliTool,
+): Promise<InstallInfo> {
+	const fallback = tool.packageManager === "pip" ? "pip" : "unknown";
 	try {
-		const { stdout } = await execAsync("brew list --formula 2>/dev/null", {
-			timeout: 2000,
+		// which -a returns all matching binaries across PATH
+		const { stdout } = await execAsync(`which -a ${tool.name} 2>/dev/null`, {
+			timeout: 3000,
 			shell: "/bin/bash",
 		});
-		const formulas = stdout.trim().split("\n");
-		return formulas.some((f) => f.trim() === toolName);
+		const paths = stdout.trim().split("\n").filter((p) => p && !p.includes("aliased"));
+		if (paths.length === 0) return { primary: fallback as InstallMethod, all: [] };
+
+		const methods: InstallMethod[] = [];
+		let brewFormula: string | undefined;
+
+		for (const binPath of paths) {
+			let method = methodFromPath(binPath);
+			let linkTarget = "";
+
+			// Check symlink target
+			try {
+				const { stdout: lt } = await execAsync(
+					`readlink "${binPath}" 2>/dev/null || true`,
+					{ timeout: 2000, shell: "/bin/bash" },
+				);
+				linkTarget = lt.trim();
+				if (!method) method = methodFromPath(linkTarget);
+			} catch {
+				// ignore
+			}
+
+			// Detect brew formula name
+			if (method === "brew" && !brewFormula) {
+				brewFormula = extractBrewFormula(binPath, linkTarget);
+			}
+
+			if (method && !methods.includes(method)) methods.push(method);
+		}
+
+		if (methods.length === 0) return { primary: fallback as InstallMethod, all: [] };
+		return { primary: methods[0]!, all: methods, brewFormula };
 	} catch {
-		return false;
+		return { primary: fallback as InstallMethod, all: [] };
+	}
+}
+
+function getUninstallCommand(tool: import("../../data/cli-tools.js").CliTool, method: InstallMethod, brewFormula?: string): string {
+	switch (method) {
+		case "bun": return `bun remove -g ${tool.packageName}`;
+		case "npm": return `npm uninstall -g ${tool.packageName}`;
+		case "pnpm": return `pnpm remove -g ${tool.packageName}`;
+		case "yarn": return `yarn global remove ${tool.packageName}`;
+		case "brew": return `brew uninstall ${brewFormula || tool.name}`;
+		case "pip": return `pip uninstall -y ${tool.packageName}`;
+		default: return "";
 	}
 }
 
+function getUpdateCommand(tool: import("../../data/cli-tools.js").CliTool, method: InstallMethod, brewFormula?: string): string {
+	switch (method) {
+		case "bun": return `bun install -g ${tool.packageName}`;
+		case "npm": return `npm install -g ${tool.packageName}`;
+		case "pnpm": return `pnpm install -g ${tool.packageName}`;
+		case "yarn": return `yarn global add ${tool.packageName}`;
+		case "brew": return `brew upgrade ${brewFormula || tool.name}`;
+		case "pip": return tool.installCommand;
+		default: return tool.installCommand;
+	}
+}
+
+
 async function getInstalledVersion(
 	tool: import("../../data/cli-tools.js").CliTool,
 ): Promise<string | undefined> {
@@ -138,22 +225,26 @@ export function CliToolsScreen() {
 	const fetchVersionInfo = useCallback(async () => {
 		for (let i = 0; i < cliTools.length; i++) {
 			const tool = cliTools[i]!;
-			getInstalledVersion(tool).then((version) => {
+
+			// Run all checks in parallel, then update with all results
+			Promise.all([
+				getInstalledVersion(tool),
+				getLatestVersion(tool),
+				detectInstallMethods(tool),
+			]).then(([version, latest, info]) => {
 				updateToolStatus(i, {
 					installedVersion: version,
 					installed: version !== undefined,
-				});
-			});
-
-			getLatestVersion(tool).then((latest) => {
-				const current = statusesRef.current[i]!;
-				updateToolStatus(i, {
 					latestVersion: latest,
 					checking: false,
 					hasUpdate:
-						current.installedVersion && latest
-							? compareVersions(current.installedVersion, latest) < 0
+						version && latest
+							? compareVersions(version, latest) < 0
 							: false,
+					installMethod: version ? info.primary : undefined,
+					allMethods: version && info.all.length > 1 ? info.all : undefined,
+					updateCommand: version ? getUpdateCommand(tool, info.primary, info.brewFormula) : undefined,
+					brewFormula: info.brewFormula,
 				});
 			});
 		}
@@ -183,7 +274,9 @@ export function CliToolsScreen() {
 			handleRefresh();
 		} else if (event.name === "a") {
 			handleUpdateAll();
-		} else if (event.name === "enter") {
+		} else if (event.name === "c") {
+			handleResolveConflict();
+		} else if (event.name === "enter" || event.name === "return") {
 			handleInstall();
 		}
 	});
@@ -202,34 +295,34 @@ export function CliToolsScreen() {
 		fetchVersionInfo();
 	};
 
+	const runCommand = async (command: string): Promise<{ ok: boolean; error?: string }> => {
+		try {
+			await execAsync(command, {
+				shell: "/bin/bash",
+				timeout: 60000,
+			});
+			return { ok: true };
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return { ok: false, error: msg };
+		}
+	};
+
 	const handleInstall = async () => {
 		const status = toolStatuses[cliToolsState.selectedIndex];
 		if (!status) return;
 
-		const { tool, installed, hasUpdate } = status;
+		const { tool, installed, hasUpdate, updateCommand } = status;
 		const action = !installed ? "Installing" : hasUpdate ? "Updating" : "Reinstalling";
-
-		const viaHomebrew = installed
-			? await isInstalledViaHomebrew(tool.name)
-			: false;
-
-		const command = !installed
-			? tool.installCommand
-			: viaHomebrew
-				? `brew upgrade ${tool.name}`
-				: tool.installCommand;
+		const command = installed && updateCommand ? updateCommand : tool.installCommand;
 
 		modal.loading(`${action} ${tool.displayName}...`);
-		try {
-			execSync(command, {
-				encoding: "utf-8",
-				stdio: "pipe",
-				shell: "/bin/bash",
-			});
-			modal.hideModal();
+		const result = await runCommand(command);
+		modal.hideModal();
+
+		if (result.ok) {
 			handleRefresh();
-		} catch (error) {
-			modal.hideModal();
+		} else {
 			await modal.message(
 				"Error",
 				`Failed to ${action.toLowerCase()} ${tool.displayName}.\n\nTry running manually:\n${command}`,
@@ -238,6 +331,49 @@ export function CliToolsScreen() {
 		}
 	};
 
+	const handleResolveConflict = async () => {
+		const status = toolStatuses[cliToolsState.selectedIndex];
+		if (!status || !status.allMethods || status.allMethods.length < 2) return;
+
+		const { tool, allMethods, installMethod, brewFormula } = status;
+
+		// Let user pick which install to keep
+		const options = allMethods.map((method) => ({
+			label: `Keep ${method}${method === installMethod ? " (active)" : ""}, remove others`,
+			value: method,
+		}));
+
+		const keep = await modal.select(
+			`Resolve ${tool.displayName} conflict`,
+			`Installed via ${allMethods.join(" + ")}. Which to keep?`,
+			options,
+		);
+		if (keep === null) return;
+
+		const toRemove = allMethods.filter((m) => m !== keep);
+		modal.loading(`Removing ${toRemove.join(", ")} install(s)...`);
+
+		const errors: string[] = [];
+		for (const method of toRemove) {
+			const cmd = getUninstallCommand(tool, method, brewFormula);
+			if (!cmd) continue;
+			const result = await runCommand(cmd);
+			if (!result.ok) errors.push(`${method}: ${cmd}`);
+		}
+
+		modal.hideModal();
+
+		if (errors.length > 0) {
+			await modal.message(
+				"Partial",
+				`Some removals failed. Try manually:\n\n${errors.join("\n")}`,
+				"error",
+			);
+		}
+
+		handleRefresh();
+	};
+
 	const handleUpdateAll = async () => {
 		const updatable = toolStatuses.filter((s) => s.hasUpdate);
 		if (updatable.length === 0) {
@@ -248,19 +384,8 @@ export function CliToolsScreen() {
 		modal.loading(`Updating ${updatable.length} tool(s)...`);
 
 		for (const status of updatable) {
-			const viaHomebrew = await isInstalledViaHomebrew(status.tool.name);
-			const command = viaHomebrew
-				? `brew upgrade ${status.tool.name}`
-				: status.tool.installCommand;
-			try {
-				execSync(command, {
-					encoding: "utf-8",
-					stdio: "pipe",
-					shell: "/bin/bash",
-				});
-			} catch {
-				// Continue with other updates
-			}
+			const command = status.updateCommand || status.tool.installCommand;
+			await runCommand(command);
 		}
 
 		modal.hideModal();
@@ -291,7 +416,7 @@ export function CliToolsScreen() {
 			title="claudeup CLI Tools"
 			currentScreen="cli-tools"
 			statusLine={statusContent}
-			footerHints="↑↓:nav │ Enter:install │ a:update all │ r:refresh"
+			footerHints="Enter:install │ a:update all │ c:fix conflict │ r:refresh"
 			listPanel={
 				<ScrollableList
 					items={toolStatuses}

package/src/ui/screens/PluginsScreen.js

@@ -198,6 +198,8 @@ export function PluginsScreen() {
             handleScopeToggle("project");
         else if (event.name === "l")
             handleScopeToggle("local");
+        else if (event.name === "d")
+            handleRemoveDeprecated();
         else if (event.name === "U")
             handleUpdate();
         else if (event.name === "a")
@@ -575,6 +577,31 @@ export function PluginsScreen() {
             await modal.message("Error", `Failed: ${error}`, "error");
         }
     };
+    const handleRemoveDeprecated = async () => {
+        const item = selectableItems[pluginsState.selectedIndex];
+        if (!item || item.kind !== "plugin" || !item.plugin.isOrphaned)
+            return;
+        const plugin = item.plugin;
+        modal.loading(`Removing ${plugin.name}...`);
+        try {
+            // Remove from all scopes — try all to clean up stale references
+            const scopes = ["user", "project", "local"];
+            for (const scope of scopes) {
+                try {
+                    await cliUninstallPlugin(plugin.id, scope, state.projectPath);
+                }
+                catch {
+                    // Ignore errors for scopes where it doesn't exist
+                }
+            }
+            modal.hideModal();
+            fetchData();
+        }
+        catch (error) {
+            modal.hideModal();
+            await modal.message("Error", `Failed to remove: ${error}`, "error");
+        }
+    };
     const handleSaveAsProfile = async () => {
         const settings = await readSettings(state.projectPath);
         const enabledPlugins = settings.enabledPlugins ?? {};

package/src/ui/screens/PluginsScreen.tsx

@@ -238,6 +238,7 @@ export function PluginsScreen() {
 		else if (event.name === "u") handleScopeToggle("user");
 		else if (event.name === "p") handleScopeToggle("project");
 		else if (event.name === "l") handleScopeToggle("local");
+		else if (event.name === "d") handleRemoveDeprecated();
 		else if (event.name === "U") handleUpdate();
 		else if (event.name === "a") handleUpdateAll();
 		else if (event.name === "s") handleSaveAsProfile();
@@ -696,6 +697,30 @@ export function PluginsScreen() {
 		}
 	};
 
+	const handleRemoveDeprecated = async () => {
+		const item = selectableItems[pluginsState.selectedIndex];
+		if (!item || item.kind !== "plugin" || !item.plugin.isOrphaned) return;
+
+		const plugin = item.plugin;
+		modal.loading(`Removing ${plugin.name}...`);
+		try {
+			// Remove from all scopes — try all to clean up stale references
+			const scopes: PluginScope[] = ["user", "project", "local"];
+			for (const scope of scopes) {
+				try {
+					await cliUninstallPlugin(plugin.id, scope, state.projectPath);
+				} catch {
+					// Ignore errors for scopes where it doesn't exist
+				}
+			}
+			modal.hideModal();
+			fetchData();
+		} catch (error) {
+			modal.hideModal();
+			await modal.message("Error", `Failed to remove: ${error}`, "error");
+		}
+	};
+
 	const handleSaveAsProfile = async () => {
 		const settings = await readSettings(state.projectPath);
 		const enabledPlugins = settings.enabledPlugins ?? {};