claudeup 4.1.0 → 4.3.0

package/src/ui/renderers/cliToolRenderers.tsx

@@ -4,6 +4,8 @@ import { theme } from "../theme.js";
 
 // ─── Status type ───────────────────────────────────────────────────────────────
 
+export type InstallMethod = "npm" | "bun" | "pnpm" | "yarn" | "brew" | "pip" | "unknown";
+
 export interface CliToolStatus {
   tool: CliTool;
   installed: boolean;
@@ -11,6 +13,24 @@ export interface CliToolStatus {
   latestVersion?: string;
   hasUpdate?: boolean;
   checking: boolean;
+  installMethod?: InstallMethod;
+  allMethods?: InstallMethod[];
+  updateCommand?: string;
+  brewFormula?: string;
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function getUninstallHint(tool: 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 ${tool.packageName}`;
+    default: return "";
+  }
 }
 
 // ─── Row renderer ──────────────────────────────────────────────────────────────
@@ -20,7 +40,8 @@ export function renderCliToolRow(
   _index: number,
   isSelected: boolean,
 ): React.ReactNode {
-  const { tool, installed, installedVersion, hasUpdate, checking } = status;
+  const { tool, installed, installedVersion, hasUpdate, checking, allMethods } = status;
+  const hasConflict = allMethods && allMethods.length > 1;
 
   let icon: string;
   let iconColor: string;
@@ -28,32 +49,38 @@ export function renderCliToolRow(
   if (!installed) {
     icon = "○";
     iconColor = theme.colors.muted;
+  } else if (hasConflict) {
+    icon = "!";
+    iconColor = theme.colors.danger;
   } else if (hasUpdate) {
-    icon = "⬆";
+    icon = "*";
     iconColor = theme.colors.warning;
   } else {
     icon = "●";
     iconColor = theme.colors.success;
   }
 
-  const versionText = installedVersion ? `v${installedVersion}` : "";
+  const versionText = installedVersion ? ` v${installedVersion}` : "";
+  const methodTag = installed && allMethods?.length
+    ? ` ${allMethods.join("+")}`
+    : "";
 
   if (isSelected) {
     return (
       <text bg={theme.selection.bg} fg={theme.selection.fg}>
-        {" "}
-        {icon} {tool.displayName} {versionText}
-        {checking ? "..." : ""}{" "}
+        {" "}{icon} {tool.displayName}{versionText}{methodTag}
+        {checking ? " ..." : ""}{" "}
       </text>
     );
   }
 
   return (
     <text>
-      <span fg={iconColor}>{icon}</span>
+      <span fg={iconColor}> {icon}</span>
       <span fg={theme.colors.text}> {tool.displayName}</span>
-      {versionText ? <span fg={theme.colors.success}> {versionText}</span> : null}
-      {checking ? <span fg={theme.colors.muted}>{"..."}</span> : null}
+      {versionText ? <span fg={theme.colors.success}>{versionText}</span> : null}
+      {methodTag ? <span fg={hasConflict ? theme.colors.danger : theme.colors.dim}>{methodTag}</span> : null}
+      {checking ? <span fg={theme.colors.muted}>{" ..."}</span> : null}
     </text>
   );
 }
@@ -76,9 +103,11 @@ export function renderCliToolDetail(
     );
   }
 
-  const { tool, installed, installedVersion, latestVersion, hasUpdate, checking } =
+  const { tool, installed, installedVersion, latestVersion, hasUpdate, checking, installMethod, allMethods, updateCommand, brewFormula } =
     status;
 
+  const hasConflict = allMethods && allMethods.length > 1;
+
   return (
     <box flexDirection="column">
       <box marginBottom={1}>
@@ -86,13 +115,14 @@ export function renderCliToolDetail(
           <strong>{"⚙ "}{tool.displayName}</strong>
         </text>
         {hasUpdate ? <text fg={theme.colors.warning}> ⬆</text> : null}
+        {hasConflict ? <text fg={theme.colors.danger}> !</text> : null}
       </box>
 
       <text fg={theme.colors.muted}>{tool.description}</text>
 
       <box marginTop={1} flexDirection="column">
         <box>
-          <text fg={theme.colors.muted}>{"Status "}</text>
+          <text fg={theme.colors.muted}>{"Status   "}</text>
           {!installed ? (
             <text fg={theme.colors.muted}>{"○ Not installed"}</text>
           ) : checking ? (
@@ -105,45 +135,89 @@ export function renderCliToolDetail(
         </box>
         {installedVersion ? (
           <box>
-            <text fg={theme.colors.muted}>{"Installed "}</text>
-            <text fg={theme.colors.success}>v{installedVersion}</text>
+            <text fg={theme.colors.muted}>{"Version  "}</text>
+            <text>
+              <span fg={theme.colors.success}>v{installedVersion}</span>
+              {latestVersion && hasUpdate ? (
+                <span fg={theme.colors.warning}> → v{latestVersion}</span>
+              ) : null}
+            </text>
+          </box>
+        ) : latestVersion ? (
+          <box>
+            <text fg={theme.colors.muted}>{"Latest   "}</text>
+            <text fg={theme.colors.text}>v{latestVersion}</text>
           </box>
         ) : null}
-        {latestVersion ? (
+        {installed && updateCommand ? (
           <box>
-            <text fg={theme.colors.muted}>{"Latest "}</text>
-            <text fg={theme.colors.text}>v{latestVersion}</text>
+            <text fg={theme.colors.muted}>{"Update   "}</text>
+            <text fg={theme.colors.accent}>{updateCommand}</text>
+          </box>
+        ) : !installed ? (
+          <box>
+            <text fg={theme.colors.muted}>{"Install  "}</text>
+            <text fg={theme.colors.accent}>{tool.installCommand}</text>
           </box>
         ) : null}
         <box>
-          <text fg={theme.colors.muted}>{"Website "}</text>
+          <text fg={theme.colors.muted}>{"Website  "}</text>
           <text fg={theme.colors.link}>{tool.website}</text>
         </box>
       </box>
 
-      <box marginTop={2}>
-        {!installed ? (
+      {/* Conflict warning */}
+      {hasConflict ? (
+        <box marginTop={1} flexDirection="column">
           <box>
-            <text bg={theme.colors.success} fg="black">
-              {" "}
-              Enter{" "}
+            <text bg={theme.colors.danger} fg="white">
+              <strong>{" "}Conflict: installed via {allMethods.join(" + ")}{" "}</strong>
+            </text>
+          </box>
+          <box marginTop={1}>
+            <text fg={theme.colors.muted}>
+              Multiple installs can cause version mismatches.
+              {"\n"}Keep one, remove the rest:
             </text>
+          </box>
+          {allMethods.map((method, i) => (
+            <box key={method}>
+              <text>
+                <span fg={i === 0 ? theme.colors.success : theme.colors.danger}>
+                  {i === 0 ? "  ● keep  " : "  ○ remove "}
+                </span>
+                <span fg={theme.colors.warning}>{method}</span>
+                {i > 0 ? (
+                  <span fg={theme.colors.dim}>{`  ${getUninstallHint(tool, method, brewFormula)}`}</span>
+                ) : (
+                  <span fg={theme.colors.dim}>  (active in PATH)</span>
+                )}
+              </text>
+            </box>
+          ))}
+          <box marginTop={1}>
+            <text bg={theme.colors.danger} fg="white">{" "}c{" "}</text>
+            <text fg={theme.colors.muted}> Resolve — pick which to keep</text>
+          </box>
+        </box>
+      ) : null}
+
+      {/* Actions */}
+      <box marginTop={2} flexDirection="column">
+        {!installed ? (
+          <box>
+            <text bg={theme.colors.success} fg="black">{" "}Enter{" "}</text>
             <text fg={theme.colors.muted}> Install</text>
+            <text fg={theme.colors.dim}>  {tool.installCommand}</text>
           </box>
         ) : hasUpdate ? (
           <box>
-            <text bg={theme.colors.warning} fg="black">
-              {" "}
-              Enter{" "}
-            </text>
+            <text bg={theme.colors.warning} fg="black">{" "}Enter{" "}</text>
             <text fg={theme.colors.muted}> Update to v{latestVersion}</text>
           </box>
         ) : (
           <box>
-            <text bg={theme.colors.muted} fg="white">
-              {" "}
-              Enter{" "}
-            </text>
+            <text bg={theme.colors.muted} fg="white">{" "}Enter{" "}</text>
             <text fg={theme.colors.muted}> Reinstall</text>
           </box>
         )}

package/src/ui/renderers/pluginRenderers.js

@@ -82,7 +82,7 @@ function pluginDetail(item) {
         plugin.localScope?.enabled;
     // Orphaned/deprecated plugin
     if (plugin.isOrphaned) {
-        return (_jsxs("box", { flexDirection: "column", children: [_jsx("box", { justifyContent: "center", children: _jsx("text", { bg: theme.colors.warning, fg: "black", children: _jsxs("strong", { children: [" ", plugin.name, " \u2014 DEPRECATED "] }) }) }), _jsx("box", { marginTop: 1, children: _jsx("text", { fg: theme.colors.warning, children: "This plugin is no longer in the marketplace." }) }), _jsx("box", { marginTop: 1, children: _jsx("text", { fg: theme.colors.muted, children: "It was removed from the marketplace but still referenced in your settings. Press d to uninstall and clean up." }) }), isInstalled ? (_jsx(ActionHints, { hints: [{ key: "d", label: "Uninstall (recommended)", tone: "danger" }] })) : null] }));
+        return (_jsxs("box", { flexDirection: "column", children: [_jsx("box", { justifyContent: "center", children: _jsx("text", { bg: theme.colors.warning, fg: "black", children: _jsxs("strong", { children: [" ", plugin.name, " \u2014 DEPRECATED "] }) }) }), _jsx("box", { marginTop: 1, children: _jsx("text", { fg: theme.colors.warning, children: "This plugin is no longer in the marketplace." }) }), _jsx("box", { marginTop: 1, children: _jsx("text", { fg: theme.colors.muted, children: "It was removed from the marketplace but still referenced in your settings. Press d to uninstall and clean up." }) }), _jsx(ActionHints, { hints: [{ key: "d", label: isInstalled ? "Remove from all scopes" : "Clean up stale reference", tone: "danger" }] })] }));
     }
     // Build component counts
     const components = [];

package/src/ui/renderers/pluginRenderers.tsx

@@ -191,11 +191,9 @@ function pluginDetail(item: PluginPluginItem): React.ReactNode {
             uninstall and clean up.
           </text>
         </box>
-        {isInstalled ? (
-          <ActionHints
-            hints={[{ key: "d", label: "Uninstall (recommended)", tone: "danger" }]}
-          />
-        ) : null}
+        <ActionHints
+          hints={[{ key: "d", label: isInstalled ? "Remove from all scopes" : "Clean up stale reference", tone: "danger" }]}
+        />
       </box>
     );
   }

package/src/ui/renderers/settingsRenderers.js

@@ -31,9 +31,11 @@ const settingRenderer = {
     renderDetail: ({ item }) => {
         const { setting } = item;
         const scoped = item.scopedValues;
-        const storageDesc = setting.storage.type === "env"
-            ? `env: ${setting.storage.key}`
-            : `settings.json: ${setting.storage.key}`;
+        const storageDesc = setting.storage.type === "attribution"
+            ? "settings.json: attribution"
+            : setting.storage.type === "env"
+                ? `env: ${setting.storage.key}`
+                : `settings.json: ${setting.storage.key}`;
         const userValue = formatValue(setting, scoped.user);
         const projectValue = formatValue(setting, scoped.project);
         const userIsSet = scoped.user !== undefined && scoped.user !== "";

package/src/ui/renderers/settingsRenderers.tsx

@@ -79,9 +79,11 @@ const settingRenderer: ItemRenderer<SettingsSettingItem> = {
     const { setting } = item;
     const scoped = item.scopedValues;
     const storageDesc =
-      setting.storage.type === "env"
-        ? `env: ${setting.storage.key}`
-        : `settings.json: ${setting.storage.key}`;
+      setting.storage.type === "attribution"
+        ? "settings.json: attribution"
+        : setting.storage.type === "env"
+          ? `env: ${setting.storage.key}`
+          : `settings.json: ${setting.storage.key}`;
 
     const userValue = formatValue(setting, scoped.user);
     const projectValue = formatValue(setting, scoped.project);

package/src/ui/screens/CliToolsScreen.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "@opentui/react/jsx-runtime";
 import { 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";
@@ -22,17 +22,94 @@ function parseVersion(versionOutput) {
     const match = versionOutput.match(/v?(\d+\.\d+\.\d+(?:-[\w.]+)?)/);
     return match ? match[1] : undefined;
 }
-async function isInstalledViaHomebrew(toolName) {
+function methodFromPath(binPath) {
+    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;
+}
+/** Extract brew formula name from a Cellar symlink target like ../Cellar/gemini-cli/0.35.2/bin/gemini */
+function extractBrewFormula(binPath, linkTarget) {
+    // 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) {
+    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, all: [] };
+        const methods = [];
+        let brewFormula;
+        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, all: [] };
+        return { primary: methods[0], all: methods, brewFormula };
     }
     catch {
-        return false;
+        return { primary: fallback, all: [] };
+    }
+}
+function getUninstallCommand(tool, method, brewFormula) {
+    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, method, brewFormula) {
+    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) {
@@ -109,20 +186,24 @@ 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
+                    hasUpdate: 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,
                 });
             });
         }
@@ -151,7 +232,10 @@ export function CliToolsScreen() {
         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();
         }
     });
@@ -166,35 +250,66 @@ export function CliToolsScreen() {
         cacheInitialized = false;
         fetchVersionInfo();
     };
+    const runCommand = async (command) => {
+        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}`, "error");
         }
     };
+    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 = [];
+        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) {
@@ -203,20 +318,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();
         handleRefresh();
@@ -225,6 +328,6 @@ export function CliToolsScreen() {
     const installedCount = toolStatuses.filter((s) => s.installed).length;
     const updateCount = toolStatuses.filter((s) => s.hasUpdate).length;
     const statusContent = (_jsxs("text", { children: [_jsx("span", { fg: "gray", children: "Installed: " }), _jsxs("span", { fg: "cyan", children: [installedCount, "/", toolStatuses.length] }), updateCount > 0 && (_jsxs(_Fragment, { children: [_jsx("span", { fg: "gray", children: " \u2502 Updates: " }), _jsx("span", { fg: "yellow", children: updateCount })] }))] }));
-    return (_jsx(ScreenLayout, { title: "claudeup CLI Tools", currentScreen: "cli-tools", statusLine: statusContent, footerHints: "\u2191\u2193:nav \u2502 Enter:install \u2502 a:update all \u2502 r:refresh", listPanel: _jsx(ScrollableList, { items: toolStatuses, selectedIndex: cliToolsState.selectedIndex, renderItem: renderCliToolRow, maxHeight: dimensions.listPanelHeight }), detailPanel: renderCliToolDetail(selectedStatus) }));
+    return (_jsx(ScreenLayout, { title: "claudeup CLI Tools", currentScreen: "cli-tools", statusLine: statusContent, footerHints: "Enter:install \u2502 a:update all \u2502 c:fix conflict \u2502 r:refresh", listPanel: _jsx(ScrollableList, { items: toolStatuses, selectedIndex: cliToolsState.selectedIndex, renderItem: renderCliToolRow, maxHeight: dimensions.listPanelHeight }), detailPanel: renderCliToolDetail(selectedStatus) }));
 }
 export default CliToolsScreen;