@xelauvas/xela-cli 0.1.0

package/src/commands/plugin/ManageMarketplaces.tsx

@@ -0,0 +1,838 @@
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import * as React from 'react';
+import { useEffect, useRef, useState } from 'react';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js';
+import { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js';
+import { Byline } from '../../components/design-system/Byline.js';
+import { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js';
+// eslint-disable-next-line custom-rules/prefer-use-keybindings -- useInput needed for marketplace-specific u/r shortcuts and y/n confirmation not in keybinding schema
+import { Box, Text, useInput } from '../../ink.js';
+import { useKeybinding, useKeybindings } from '../../keybindings/useKeybinding.js';
+import type { LoadedPlugin } from '../../types/plugin.js';
+import { count } from '../../utils/array.js';
+import { shouldSkipPluginAutoupdate } from '../../utils/config.js';
+import { errorMessage } from '../../utils/errors.js';
+import { clearAllCaches } from '../../utils/plugins/cacheUtils.js';
+import { createPluginId, formatMarketplaceLoadingErrors, getMarketplaceSourceDisplay, loadMarketplacesWithGracefulDegradation } from '../../utils/plugins/marketplaceHelpers.js';
+import { loadKnownMarketplacesConfig, refreshMarketplace, removeMarketplaceSource, setMarketplaceAutoUpdate } from '../../utils/plugins/marketplaceManager.js';
+import { updatePluginsForMarketplaces } from '../../utils/plugins/pluginAutoupdate.js';
+import { loadAllPlugins } from '../../utils/plugins/pluginLoader.js';
+import { isMarketplaceAutoUpdate } from '../../utils/plugins/schemas.js';
+import { getSettingsForSource, updateSettingsForSource } from '../../utils/settings/settings.js';
+import { plural } from '../../utils/stringUtils.js';
+import type { ViewState } from './types.js';
+type Props = {
+  setViewState: (state: ViewState) => void;
+  error?: string | null;
+  setError?: (error: string | null) => void;
+  setResult: (result: string | null) => void;
+  exitState: {
+    pending: boolean;
+    keyName: 'Ctrl-C' | 'Ctrl-D' | null;
+  };
+  onManageComplete?: () => void | Promise<void>;
+  targetMarketplace?: string;
+  action?: 'update' | 'remove';
+};
+type MarketplaceState = {
+  name: string;
+  source: string;
+  lastUpdated?: string;
+  pluginCount?: number;
+  installedPlugins?: LoadedPlugin[];
+  pendingUpdate?: boolean;
+  pendingRemove?: boolean;
+  autoUpdate?: boolean;
+};
+type InternalViewState = 'list' | 'details' | 'confirm-remove';
+export function ManageMarketplaces({
+  setViewState,
+  error,
+  setError,
+  setResult,
+  exitState,
+  onManageComplete,
+  targetMarketplace,
+  action
+}: Props): React.ReactNode {
+  const [marketplaceStates, setMarketplaceStates] = useState<MarketplaceState[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [processError, setProcessError] = useState<string | null>(null);
+  const [successMessage, setSuccessMessage] = useState<string | null>(null);
+  const [progressMessage, setProgressMessage] = useState<string | null>(null);
+  const [internalView, setInternalView] = useState<InternalViewState>('list');
+  const [selectedMarketplace, setSelectedMarketplace] = useState<MarketplaceState | null>(null);
+  const [detailsMenuIndex, setDetailsMenuIndex] = useState(0);
+  const hasAttemptedAutoAction = useRef(false);
+
+  // Load marketplaces and their installed plugins
+  useEffect(() => {
+    async function loadMarketplaces() {
+      try {
+        const config = await loadKnownMarketplacesConfig();
+        const {
+          enabled,
+          disabled
+        } = await loadAllPlugins();
+        const allPlugins = [...enabled, ...disabled];
+
+        // Load marketplaces with graceful degradation
+        const {
+          marketplaces,
+          failures
+        } = await loadMarketplacesWithGracefulDegradation(config);
+        const states: MarketplaceState[] = [];
+        for (const {
+          name,
+          config: entry,
+          data: marketplace
+        } of marketplaces) {
+          // Get all plugins installed from this marketplace
+          const installedFromMarketplace = allPlugins.filter(plugin => plugin.source.endsWith(`@${name}`));
+          states.push({
+            name,
+            source: getMarketplaceSourceDisplay(entry.source),
+            lastUpdated: entry.lastUpdated,
+            pluginCount: marketplace?.plugins.length,
+            installedPlugins: installedFromMarketplace,
+            pendingUpdate: false,
+            pendingRemove: false,
+            autoUpdate: isMarketplaceAutoUpdate(name, entry)
+          });
+        }
+
+        // Sort: claude-plugin-directory first, then alphabetically
+        states.sort((a, b) => {
+          if (a.name === 'claude-plugin-directory') return -1;
+          if (b.name === 'claude-plugin-directory') return 1;
+          return a.name.localeCompare(b.name);
+        });
+        setMarketplaceStates(states);
+
+        // Handle marketplace loading errors/warnings
+        const successCount = count(marketplaces, m => m.data !== null);
+        const errorResult = formatMarketplaceLoadingErrors(failures, successCount);
+        if (errorResult) {
+          if (errorResult.type === 'warning') {
+            setProcessError(errorResult.message);
+          } else {
+            throw new Error(errorResult.message);
+          }
+        }
+
+        // Auto-execute if target and action provided
+        if (targetMarketplace && !hasAttemptedAutoAction.current && !error) {
+          hasAttemptedAutoAction.current = true;
+          const targetIndex = states.findIndex(s => s.name === targetMarketplace);
+          if (targetIndex >= 0) {
+            const targetState = states[targetIndex];
+            if (action) {
+              // Mark the action as pending and execute
+              setSelectedIndex(targetIndex + 1); // +1 because "Add Marketplace" is at index 0
+              const newStates = [...states];
+              if (action === 'update') {
+                newStates[targetIndex]!.pendingUpdate = true;
+              } else if (action === 'remove') {
+                newStates[targetIndex]!.pendingRemove = true;
+              }
+              setMarketplaceStates(newStates);
+              // Apply the change immediately
+              setTimeout(applyChanges, 100, newStates);
+            } else if (targetState) {
+              // No action - just show the details view for this marketplace
+              setSelectedIndex(targetIndex + 1); // +1 because "Add Marketplace" is at index 0
+              setSelectedMarketplace(targetState);
+              setInternalView('details');
+            }
+          } else if (setError) {
+            setError(`Marketplace not found: ${targetMarketplace}`);
+          }
+        }
+      } catch (err) {
+        if (setError) {
+          setError(err instanceof Error ? err.message : 'Failed to load marketplaces');
+        }
+        setProcessError(err instanceof Error ? err.message : 'Failed to load marketplaces');
+      } finally {
+        setLoading(false);
+      }
+    }
+    void loadMarketplaces();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    // biome-ignore lint/correctness/useExhaustiveDependencies: intentional
+  }, [targetMarketplace, action, error]);
+
+  // Check if there are any pending changes
+  const hasPendingChanges = () => {
+    return marketplaceStates.some(state => state.pendingUpdate || state.pendingRemove);
+  };
+
+  // Get count of pending operations
+  const getPendingCounts = () => {
+    const updateCount = count(marketplaceStates, s => s.pendingUpdate);
+    const removeCount = count(marketplaceStates, s => s.pendingRemove);
+    return {
+      updateCount,
+      removeCount
+    };
+  };
+
+  // Apply all pending changes
+  const applyChanges = async (states?: MarketplaceState[]) => {
+    const statesToProcess = states || marketplaceStates;
+    const wasInDetailsView = internalView === 'details';
+    setIsProcessing(true);
+    setProcessError(null);
+    setSuccessMessage(null);
+    setProgressMessage(null);
+    try {
+      const settings = getSettingsForSource('userSettings');
+      let updatedCount = 0;
+      let removedCount = 0;
+      const refreshedMarketplaces = new Set<string>();
+      for (const state of statesToProcess) {
+        // Handle remove
+        if (state.pendingRemove) {
+          // First uninstall all plugins from this marketplace
+          if (state.installedPlugins && state.installedPlugins.length > 0) {
+            const newEnabledPlugins = {
+              ...settings?.enabledPlugins
+            };
+            for (const plugin of state.installedPlugins) {
+              const pluginId = createPluginId(plugin.name, state.name);
+              // Mark as disabled/uninstalled
+              newEnabledPlugins[pluginId] = false;
+            }
+            updateSettingsForSource('userSettings', {
+              enabledPlugins: newEnabledPlugins
+            });
+          }
+
+          // Then remove the marketplace
+          await removeMarketplaceSource(state.name);
+          removedCount++;
+          logEvent('tengu_marketplace_removed', {
+            marketplace_name: state.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+            plugins_uninstalled: state.installedPlugins?.length || 0
+          });
+          continue;
+        }
+
+        // Handle update
+        if (state.pendingUpdate) {
+          // Refresh individual marketplace for efficiency with progress reporting
+          await refreshMarketplace(state.name, (message: string) => {
+            setProgressMessage(message);
+          });
+          updatedCount++;
+          refreshedMarketplaces.add(state.name.toLowerCase());
+          logEvent('tengu_marketplace_updated', {
+            marketplace_name: state.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+          });
+        }
+      }
+
+      // After marketplace clones are refreshed, bump installed plugins from
+      // those marketplaces to the new version. Without this, the loader's
+      // cache-on-miss (copyPluginToVersionedCache) creates the new version
+      // dir on the next loadAllPlugins() call, but installed_plugins.json
+      // stays on the old version — so cleanupOrphanedPluginVersionsInBackground
+      // stamps the NEW dir with .orphaned_at on the next startup. See #29512.
+      // updatePluginOp (called inside the helper) is what actually writes
+      // installed_plugins.json via updateInstallationPathOnDisk.
+      let updatedPluginCount = 0;
+      if (refreshedMarketplaces.size > 0) {
+        const updatedPluginIds = await updatePluginsForMarketplaces(refreshedMarketplaces);
+        updatedPluginCount = updatedPluginIds.length;
+      }
+
+      // Clear caches after changes
+      clearAllCaches();
+
+      // Call completion callback
+      if (onManageComplete) {
+        await onManageComplete();
+      }
+
+      // Reload marketplace data to show updated timestamps
+      const config = await loadKnownMarketplacesConfig();
+      const {
+        enabled,
+        disabled
+      } = await loadAllPlugins();
+      const allPlugins = [...enabled, ...disabled];
+      const {
+        marketplaces
+      } = await loadMarketplacesWithGracefulDegradation(config);
+      const newStates: MarketplaceState[] = [];
+      for (const {
+        name,
+        config: entry,
+        data: marketplace
+      } of marketplaces) {
+        const installedFromMarketplace = allPlugins.filter(plugin => plugin.source.endsWith(`@${name}`));
+        newStates.push({
+          name,
+          source: getMarketplaceSourceDisplay(entry.source),
+          lastUpdated: entry.lastUpdated,
+          pluginCount: marketplace?.plugins.length,
+          installedPlugins: installedFromMarketplace,
+          pendingUpdate: false,
+          pendingRemove: false,
+          autoUpdate: isMarketplaceAutoUpdate(name, entry)
+        });
+      }
+
+      // Sort: claude-plugin-directory first, then alphabetically
+      newStates.sort((a, b) => {
+        if (a.name === 'claude-plugin-directory') return -1;
+        if (b.name === 'claude-plugin-directory') return 1;
+        return a.name.localeCompare(b.name);
+      });
+      setMarketplaceStates(newStates);
+
+      // Update selected marketplace reference with fresh data
+      if (wasInDetailsView && selectedMarketplace) {
+        const updatedMarketplace = newStates.find(s => s.name === selectedMarketplace.name);
+        if (updatedMarketplace) {
+          setSelectedMarketplace(updatedMarketplace);
+        }
+      }
+
+      // Build success message
+      const actions: string[] = [];
+      if (updatedCount > 0) {
+        const pluginPart = updatedPluginCount > 0 ? ` (${updatedPluginCount} ${plural(updatedPluginCount, 'plugin')} bumped)` : '';
+        actions.push(`Updated ${updatedCount} ${plural(updatedCount, 'marketplace')}${pluginPart}`);
+      }
+      if (removedCount > 0) {
+        actions.push(`Removed ${removedCount} ${plural(removedCount, 'marketplace')}`);
+      }
+      if (actions.length > 0) {
+        const successMsg = `${figures.tick} ${actions.join(', ')}`;
+        // If we were in details view, stay there and show success
+        if (wasInDetailsView) {
+          setSuccessMessage(successMsg);
+        } else {
+          // Otherwise show result and exit to menu
+          setResult(successMsg);
+          setTimeout(setViewState, 2000, {
+            type: 'menu' as const
+          });
+        }
+      } else if (!wasInDetailsView) {
+        setViewState({
+          type: 'menu'
+        });
+      }
+    } catch (err) {
+      const errorMsg = errorMessage(err);
+      setProcessError(errorMsg);
+      if (setError) {
+        setError(errorMsg);
+      }
+    } finally {
+      setIsProcessing(false);
+      setProgressMessage(null);
+    }
+  };
+
+  // Handle confirming marketplace removal
+  const confirmRemove = async () => {
+    if (!selectedMarketplace) return;
+
+    // Mark for removal and apply
+    const newStates = marketplaceStates.map(state => state.name === selectedMarketplace.name ? {
+      ...state,
+      pendingRemove: true
+    } : state);
+    setMarketplaceStates(newStates);
+    await applyChanges(newStates);
+  };
+
+  // Build menu options for details view
+  const buildDetailsMenuOptions = (marketplace: MarketplaceState | null): Array<{
+    label: string;
+    secondaryLabel?: string;
+    value: string;
+  }> => {
+    if (!marketplace) return [];
+    const options: Array<{
+      label: string;
+      secondaryLabel?: string;
+      value: string;
+    }> = [{
+      label: `Browse plugins (${marketplace.pluginCount ?? 0})`,
+      value: 'browse'
+    }, {
+      label: 'Update marketplace',
+      secondaryLabel: marketplace.lastUpdated ? `(last updated ${new Date(marketplace.lastUpdated).toLocaleDateString()})` : undefined,
+      value: 'update'
+    }];
+
+    // Only show auto-update toggle if auto-updater is not globally disabled
+    if (!shouldSkipPluginAutoupdate()) {
+      options.push({
+        label: marketplace.autoUpdate ? 'Disable auto-update' : 'Enable auto-update',
+        value: 'toggle-auto-update'
+      });
+    }
+    options.push({
+      label: 'Remove marketplace',
+      value: 'remove'
+    });
+    return options;
+  };
+
+  // Handle toggling auto-update for a marketplace
+  const handleToggleAutoUpdate = async (marketplace: MarketplaceState) => {
+    const newAutoUpdate = !marketplace.autoUpdate;
+    try {
+      await setMarketplaceAutoUpdate(marketplace.name, newAutoUpdate);
+
+      // Update local state
+      setMarketplaceStates(prev => prev.map(state => state.name === marketplace.name ? {
+        ...state,
+        autoUpdate: newAutoUpdate
+      } : state));
+
+      // Update selected marketplace reference
+      setSelectedMarketplace(prev => prev ? {
+        ...prev,
+        autoUpdate: newAutoUpdate
+      } : prev);
+    } catch (err) {
+      setProcessError(err instanceof Error ? err.message : 'Failed to update setting');
+    }
+  };
+
+  // Escape in details or confirm-remove view - go back to list
+  useKeybinding('confirm:no', () => {
+    setInternalView('list');
+    setDetailsMenuIndex(0);
+  }, {
+    context: 'Confirmation',
+    isActive: !isProcessing && (internalView === 'details' || internalView === 'confirm-remove')
+  });
+
+  // Escape in list view with pending changes - clear pending changes
+  useKeybinding('confirm:no', () => {
+    setMarketplaceStates(prev => prev.map(state => ({
+      ...state,
+      pendingUpdate: false,
+      pendingRemove: false
+    })));
+    setSelectedIndex(0);
+  }, {
+    context: 'Confirmation',
+    isActive: !isProcessing && internalView === 'list' && hasPendingChanges()
+  });
+
+  // Escape in list view without pending changes - exit to parent menu
+  useKeybinding('confirm:no', () => {
+    setViewState({
+      type: 'menu'
+    });
+  }, {
+    context: 'Confirmation',
+    isActive: !isProcessing && internalView === 'list' && !hasPendingChanges()
+  });
+
+  // List view — navigation (up/down/enter via configurable keybindings)
+  useKeybindings({
+    'select:previous': () => setSelectedIndex(prev => Math.max(0, prev - 1)),
+    'select:next': () => {
+      const totalItems = marketplaceStates.length + 1;
+      setSelectedIndex(prev => Math.min(totalItems - 1, prev + 1));
+    },
+    'select:accept': () => {
+      const marketplaceIndex = selectedIndex - 1;
+      if (selectedIndex === 0) {
+        setViewState({
+          type: 'add-marketplace'
+        });
+      } else if (hasPendingChanges()) {
+        void applyChanges();
+      } else {
+        const marketplace = marketplaceStates[marketplaceIndex];
+        if (marketplace) {
+          setSelectedMarketplace(marketplace);
+          setInternalView('details');
+          setDetailsMenuIndex(0);
+        }
+      }
+    }
+  }, {
+    context: 'Select',
+    isActive: !isProcessing && internalView === 'list'
+  });
+
+  // List view — marketplace-specific actions (u/r shortcuts)
+  useInput(input => {
+    const marketplaceIndex = selectedIndex - 1;
+    if ((input === 'u' || input === 'U') && marketplaceIndex >= 0) {
+      setMarketplaceStates(prev => prev.map((state, idx) => idx === marketplaceIndex ? {
+        ...state,
+        pendingUpdate: !state.pendingUpdate,
+        pendingRemove: state.pendingUpdate ? state.pendingRemove : false
+      } : state));
+    } else if ((input === 'r' || input === 'R') && marketplaceIndex >= 0) {
+      const marketplace = marketplaceStates[marketplaceIndex];
+      if (marketplace) {
+        setSelectedMarketplace(marketplace);
+        setInternalView('confirm-remove');
+      }
+    }
+  }, {
+    isActive: !isProcessing && internalView === 'list'
+  });
+
+  // Details view — navigation
+  useKeybindings({
+    'select:previous': () => setDetailsMenuIndex(prev => Math.max(0, prev - 1)),
+    'select:next': () => {
+      const menuOptions = buildDetailsMenuOptions(selectedMarketplace);
+      setDetailsMenuIndex(prev => Math.min(menuOptions.length - 1, prev + 1));
+    },
+    'select:accept': () => {
+      if (!selectedMarketplace) return;
+      const menuOptions = buildDetailsMenuOptions(selectedMarketplace);
+      const selectedOption = menuOptions[detailsMenuIndex];
+      if (selectedOption?.value === 'browse') {
+        setViewState({
+          type: 'browse-marketplace',
+          targetMarketplace: selectedMarketplace.name
+        });
+      } else if (selectedOption?.value === 'update') {
+        const newStates = marketplaceStates.map(state => state.name === selectedMarketplace.name ? {
+          ...state,
+          pendingUpdate: true
+        } : state);
+        setMarketplaceStates(newStates);
+        void applyChanges(newStates);
+      } else if (selectedOption?.value === 'toggle-auto-update') {
+        void handleToggleAutoUpdate(selectedMarketplace);
+      } else if (selectedOption?.value === 'remove') {
+        setInternalView('confirm-remove');
+      }
+    }
+  }, {
+    context: 'Select',
+    isActive: !isProcessing && internalView === 'details'
+  });
+
+  // Confirm-remove view — y/n input
+  useInput(input => {
+    if (input === 'y' || input === 'Y') {
+      void confirmRemove();
+    } else if (input === 'n' || input === 'N') {
+      setInternalView('list');
+      setSelectedMarketplace(null);
+    }
+  }, {
+    isActive: !isProcessing && internalView === 'confirm-remove'
+  });
+  if (loading) {
+    return <Text>Loading marketplaces…</Text>;
+  }
+  if (marketplaceStates.length === 0) {
+    return <Box flexDirection="column">
+        <Box marginBottom={1}>
+          <Text bold>Manage marketplaces</Text>
+        </Box>
+
+        {/* Add Marketplace option */}
+        <Box flexDirection="row" gap={1}>
+          <Text color="suggestion">{figures.pointer} +</Text>
+          <Text bold color="suggestion">
+            Add Marketplace
+          </Text>
+        </Box>
+
+        <Box marginLeft={3}>
+          <Text dimColor italic>
+            {exitState.pending ? <>Press {exitState.keyName} again to go back</> : <Byline>
+                <ConfigurableShortcutHint action="select:accept" context="Select" fallback="Enter" description="select" />
+                <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="go back" />
+              </Byline>}
+          </Text>
+        </Box>
+      </Box>;
+  }
+
+  // Show confirmation dialog
+  if (internalView === 'confirm-remove' && selectedMarketplace) {
+    const pluginCount = selectedMarketplace.installedPlugins?.length || 0;
+    return <Box flexDirection="column">
+        <Text bold color="warning">
+          Remove marketplace <Text italic>{selectedMarketplace.name}</Text>?
+        </Text>
+        <Box flexDirection="column">
+          {pluginCount > 0 && <Box marginTop={1}>
+              <Text color="warning">
+                This will also uninstall {pluginCount}{' '}
+                {plural(pluginCount, 'plugin')} from this marketplace:
+              </Text>
+            </Box>}
+          {selectedMarketplace.installedPlugins && selectedMarketplace.installedPlugins.length > 0 && <Box flexDirection="column" marginTop={1} marginLeft={2}>
+                {selectedMarketplace.installedPlugins.map(plugin => <Text key={plugin.name} dimColor>
+                    • {plugin.name}
+                  </Text>)}
+              </Box>}
+          <Box marginTop={1}>
+            <Text>
+              Press <Text bold>y</Text> to confirm or <Text bold>n</Text> to
+              cancel
+            </Text>
+          </Box>
+        </Box>
+      </Box>;
+  }
+
+  // Show marketplace details
+  if (internalView === 'details' && selectedMarketplace) {
+    // Check if this marketplace is currently being processed
+    // Check pendingUpdate first so we show updating state immediately when user presses Enter
+    const isUpdating = selectedMarketplace.pendingUpdate || isProcessing;
+    const menuOptions = buildDetailsMenuOptions(selectedMarketplace);
+    return <Box flexDirection="column">
+        <Text bold>{selectedMarketplace.name}</Text>
+        <Text dimColor>{selectedMarketplace.source}</Text>
+        <Box marginTop={1}>
+          <Text>
+            {selectedMarketplace.pluginCount || 0} available{' '}
+            {plural(selectedMarketplace.pluginCount || 0, 'plugin')}
+          </Text>
+        </Box>
+
+        {/* Installed plugins section */}
+        {selectedMarketplace.installedPlugins && selectedMarketplace.installedPlugins.length > 0 && <Box flexDirection="column" marginTop={1}>
+              <Text bold>
+                Installed plugins ({selectedMarketplace.installedPlugins.length}
+                ):
+              </Text>
+              <Box flexDirection="column" marginLeft={1}>
+                {selectedMarketplace.installedPlugins.map(plugin => <Box key={plugin.name} flexDirection="row" gap={1}>
+                    <Text>{figures.bullet}</Text>
+                    <Box flexDirection="column">
+                      <Text>{plugin.name}</Text>
+                      <Text dimColor>{plugin.manifest.description}</Text>
+                    </Box>
+                  </Box>)}
+              </Box>
+            </Box>}
+
+        {/* Processing indicator */}
+        {isUpdating && <Box marginTop={1} flexDirection="column">
+            <Text color="claude">Updating marketplace…</Text>
+            {progressMessage && <Text dimColor>{progressMessage}</Text>}
+          </Box>}
+
+        {/* Success message */}
+        {!isUpdating && successMessage && <Box marginTop={1}>
+            <Text color="claude">{successMessage}</Text>
+          </Box>}
+
+        {/* Error message */}
+        {!isUpdating && processError && <Box marginTop={1}>
+            <Text color="error">{processError}</Text>
+          </Box>}
+
+        {/* Menu options */}
+        {!isUpdating && <Box flexDirection="column" marginTop={1}>
+            {menuOptions.map((option, idx) => {
+          if (!option) return null;
+          const isSelected = idx === detailsMenuIndex;
+          return <Box key={option.value}>
+                  <Text color={isSelected ? 'suggestion' : undefined}>
+                    {isSelected ? figures.pointer : ' '} {option.label}
+                  </Text>
+                  {option.secondaryLabel && <Text dimColor> {option.secondaryLabel}</Text>}
+                </Box>;
+        })}
+          </Box>}
+
+        {/* Show explanatory text at the bottom when auto-update is enabled */}
+        {!isUpdating && !shouldSkipPluginAutoupdate() && selectedMarketplace.autoUpdate && <Box marginTop={1}>
+              <Text dimColor>
+                Auto-update enabled. Claude Code will automatically update this
+                marketplace and its installed plugins.
+              </Text>
+            </Box>}
+
+        <Box marginLeft={3}>
+          <Text dimColor italic>
+            {isUpdating ? <>Please wait…</> : <Byline>
+                <ConfigurableShortcutHint action="select:accept" context="Select" fallback="Enter" description="select" />
+                <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="go back" />
+              </Byline>}
+          </Text>
+        </Box>
+      </Box>;
+  }
+
+  // Show marketplace list
+  const {
+    updateCount,
+    removeCount
+  } = getPendingCounts();
+  return <Box flexDirection="column">
+      <Box marginBottom={1}>
+        <Text bold>Manage marketplaces</Text>
+      </Box>
+
+      {/* Add Marketplace option */}
+      <Box flexDirection="row" gap={1} marginBottom={1}>
+        <Text color={selectedIndex === 0 ? 'suggestion' : undefined}>
+          {selectedIndex === 0 ? figures.pointer : ' '} +
+        </Text>
+        <Text bold color={selectedIndex === 0 ? 'suggestion' : undefined}>
+          Add Marketplace
+        </Text>
+      </Box>
+
+      {/* Marketplace list */}
+      <Box flexDirection="column">
+        {marketplaceStates.map((state, idx) => {
+        const isSelected = idx + 1 === selectedIndex; // +1 because Add Marketplace is at index 0
+
+        // Build status indicators
+        const indicators: string[] = [];
+        if (state.pendingUpdate) indicators.push('UPDATE');
+        if (state.pendingRemove) indicators.push('REMOVE');
+        return <Box key={state.name} flexDirection="row" gap={1} marginBottom={1}>
+              <Text color={isSelected ? 'suggestion' : undefined}>
+                {isSelected ? figures.pointer : ' '}{' '}
+                {state.pendingRemove ? figures.cross : figures.bullet}
+              </Text>
+              <Box flexDirection="column" flexGrow={1}>
+                <Box flexDirection="row" gap={1}>
+                  <Text bold strikethrough={state.pendingRemove} dimColor={state.pendingRemove}>
+                    {state.name === 'claude-plugins-official' && <Text color="claude">✻ </Text>}
+                    {state.name}
+                    {state.name === 'claude-plugins-official' && <Text color="claude"> ✻</Text>}
+                  </Text>
+                  {indicators.length > 0 && <Text color="warning">[{indicators.join(', ')}]</Text>}
+                </Box>
+                <Text dimColor>{state.source}</Text>
+                <Text dimColor>
+                  {state.pluginCount !== undefined && <>{state.pluginCount} available</>}
+                  {state.installedPlugins && state.installedPlugins.length > 0 && <> • {state.installedPlugins.length} installed</>}
+                  {state.lastUpdated && <>
+                      {' '}
+                      • Updated{' '}
+                      {new Date(state.lastUpdated).toLocaleDateString()}
+                    </>}
+                </Text>
+              </Box>
+            </Box>;
+      })}
+      </Box>
+
+      {/* Pending changes summary */}
+      {hasPendingChanges() && <Box marginTop={1} flexDirection="column">
+          <Text>
+            <Text bold>Pending changes:</Text>{' '}
+            <Text dimColor>Enter to apply</Text>
+          </Text>
+          {updateCount > 0 && <Text>
+              • Update {updateCount} {plural(updateCount, 'marketplace')}
+            </Text>}
+          {removeCount > 0 && <Text color="warning">
+              • Remove {removeCount} {plural(removeCount, 'marketplace')}
+            </Text>}
+        </Box>}
+
+      {/* Processing indicator */}
+      {isProcessing && <Box marginTop={1}>
+          <Text color="claude">Processing changes…</Text>
+        </Box>}
+
+      {/* Error display */}
+      {processError && <Box marginTop={1}>
+          <Text color="error">{processError}</Text>
+        </Box>}
+
+      <ManageMarketplacesKeyHints exitState={exitState} hasPendingActions={hasPendingChanges()} />
+    </Box>;
+}
+type ManageMarketplacesKeyHintsProps = {
+  exitState: Props['exitState'];
+  hasPendingActions: boolean;
+};
+function ManageMarketplacesKeyHints(t0) {
+  const $ = _c(18);
+  const {
+    exitState,
+    hasPendingActions
+  } = t0;
+  if (exitState.pending) {
+    let t1;
+    if ($[0] !== exitState.keyName) {
+      t1 = <Box marginTop={1}><Text dimColor={true} italic={true}>Press {exitState.keyName} again to go back</Text></Box>;
+      $[0] = exitState.keyName;
+      $[1] = t1;
+    } else {
+      t1 = $[1];
+    }
+    return t1;
+  }
+  let t1;
+  if ($[2] !== hasPendingActions) {
+    t1 = hasPendingActions && <ConfigurableShortcutHint action="select:accept" context="Select" fallback="Enter" description="apply changes" />;
+    $[2] = hasPendingActions;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  let t2;
+  if ($[4] !== hasPendingActions) {
+    t2 = !hasPendingActions && <ConfigurableShortcutHint action="select:accept" context="Select" fallback="Enter" description="select" />;
+    $[4] = hasPendingActions;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  let t3;
+  if ($[6] !== hasPendingActions) {
+    t3 = !hasPendingActions && <KeyboardShortcutHint shortcut="u" action="update" />;
+    $[6] = hasPendingActions;
+    $[7] = t3;
+  } else {
+    t3 = $[7];
+  }
+  let t4;
+  if ($[8] !== hasPendingActions) {
+    t4 = !hasPendingActions && <KeyboardShortcutHint shortcut="r" action="remove" />;
+    $[8] = hasPendingActions;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  const t5 = hasPendingActions ? "cancel" : "go back";
+  let t6;
+  if ($[10] !== t5) {
+    t6 = <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description={t5} />;
+    $[10] = t5;
+    $[11] = t6;
+  } else {
+    t6 = $[11];
+  }
+  let t7;
+  if ($[12] !== t1 || $[13] !== t2 || $[14] !== t3 || $[15] !== t4 || $[16] !== t6) {
+    t7 = <Box marginTop={1}><Text dimColor={true} italic={true}><Byline>{t1}{t2}{t3}{t4}{t6}</Byline></Text></Box>;
+    $[12] = t1;
+    $[13] = t2;
+    $[14] = t3;
+    $[15] = t4;
+    $[16] = t6;
+    $[17] = t7;
+  } else {
+    t7 = $[17];
+  }
+  return t7;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","useEffect","useRef","useState","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","ConfigurableShortcutHint","Byline","KeyboardShortcutHint","Box","Text","useInput","useKeybinding","useKeybindings","LoadedPlugin","count","shouldSkipPluginAutoupdate","errorMessage","clearAllCaches","createPluginId","formatMarketplaceLoadingErrors","getMarketplaceSourceDisplay","loadMarketplacesWithGracefulDegradation","loadKnownMarketplacesConfig","refreshMarketplace","removeMarketplaceSource","setMarketplaceAutoUpdate","updatePluginsForMarketplaces","loadAllPlugins","isMarketplaceAutoUpdate","getSettingsForSource","updateSettingsForSource","plural","ViewState","Props","setViewState","state","error","setError","setResult","result","exitState","pending","keyName","onManageComplete","Promise","targetMarketplace","action","MarketplaceState","name","source","lastUpdated","pluginCount","installedPlugins","pendingUpdate","pendingRemove","autoUpdate","InternalViewState","ManageMarketplaces","ReactNode","marketplaceStates","setMarketplaceStates","loading","setLoading","selectedIndex","setSelectedIndex","isProcessing","setIsProcessing","processError","setProcessError","successMessage","setSuccessMessage","progressMessage","setProgressMessage","internalView","setInternalView","selectedMarketplace","setSelectedMarketplace","detailsMenuIndex","setDetailsMenuIndex","hasAttemptedAutoAction","loadMarketplaces","config","enabled","disabled","allPlugins","marketplaces","failures","states","entry","data","marketplace","installedFromMarketplace","filter","plugin","endsWith","push","plugins","length","sort","a","b","localeCompare","successCount","m","errorResult","type","message","Error","current","targetIndex","findIndex","s","targetState","newStates","setTimeout","applyChanges","err","hasPendingChanges","some","getPendingCounts","updateCount","removeCount","statesToProcess","wasInDetailsView","settings","updatedCount","removedCount","refreshedMarketplaces","Set","newEnabledPlugins","enabledPlugins","pluginId","marketplace_name","plugins_uninstalled","add","toLowerCase","updatedPluginCount","size","updatedPluginIds","updatedMarketplace","find","actions","pluginPart","successMsg","tick","join","const","errorMsg","confirmRemove","map","buildDetailsMenuOptions","Array","label","secondaryLabel","value","options","Date","toLocaleDateString","undefined","handleToggleAutoUpdate","newAutoUpdate","prev","context","isActive","select:previous","Math","max","select:next","totalItems","min","select:accept","marketplaceIndex","input","idx","menuOptions","selectedOption","pointer","isUpdating","bullet","manifest","description","option","isSelected","indicators","cross","ManageMarketplacesKeyHintsProps","hasPendingActions","ManageMarketplacesKeyHints","t0","$","_c","t1","t2","t3","t4","t5","t6","t7"],"sources":["ManageMarketplaces.tsx"],"sourcesContent":["import figures from 'figures'\nimport * as React from 'react'\nimport { useEffect, useRef, useState } from 'react'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from 'src/services/analytics/index.js'\nimport { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'\nimport { Byline } from '../../components/design-system/Byline.js'\nimport { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js'\n// eslint-disable-next-line custom-rules/prefer-use-keybindings -- useInput needed for marketplace-specific u/r shortcuts and y/n confirmation not in keybinding schema\nimport { Box, Text, useInput } from '../../ink.js'\nimport {\n  useKeybinding,\n  useKeybindings,\n} from '../../keybindings/useKeybinding.js'\nimport type { LoadedPlugin } from '../../types/plugin.js'\nimport { count } from '../../utils/array.js'\nimport { shouldSkipPluginAutoupdate } from '../../utils/config.js'\nimport { errorMessage } from '../../utils/errors.js'\nimport { clearAllCaches } from '../../utils/plugins/cacheUtils.js'\nimport {\n  createPluginId,\n  formatMarketplaceLoadingErrors,\n  getMarketplaceSourceDisplay,\n  loadMarketplacesWithGracefulDegradation,\n} from '../../utils/plugins/marketplaceHelpers.js'\nimport {\n  loadKnownMarketplacesConfig,\n  refreshMarketplace,\n  removeMarketplaceSource,\n  setMarketplaceAutoUpdate,\n} from '../../utils/plugins/marketplaceManager.js'\nimport { updatePluginsForMarketplaces } from '../../utils/plugins/pluginAutoupdate.js'\nimport { loadAllPlugins } from '../../utils/plugins/pluginLoader.js'\nimport { isMarketplaceAutoUpdate } from '../../utils/plugins/schemas.js'\nimport {\n  getSettingsForSource,\n  updateSettingsForSource,\n} from '../../utils/settings/settings.js'\nimport { plural } from '../../utils/stringUtils.js'\nimport type { ViewState } from './types.js'\n\ntype Props = {\n  setViewState: (state: ViewState) => void\n  error?: string | null\n  setError?: (error: string | null) => void\n  setResult: (result: string | null) => void\n  exitState: {\n    pending: boolean\n    keyName: 'Ctrl-C' | 'Ctrl-D' | null\n  }\n  onManageComplete?: () => void | Promise<void>\n  targetMarketplace?: string\n  action?: 'update' | 'remove'\n}\n\ntype MarketplaceState = {\n  name: string\n  source: string\n  lastUpdated?: string\n  pluginCount?: number\n  installedPlugins?: LoadedPlugin[]\n  pendingUpdate?: boolean\n  pendingRemove?: boolean\n  autoUpdate?: boolean\n}\n\ntype InternalViewState = 'list' | 'details' | 'confirm-remove'\n\nexport function ManageMarketplaces({\n  setViewState,\n  error,\n  setError,\n  setResult,\n  exitState,\n  onManageComplete,\n  targetMarketplace,\n  action,\n}: Props): React.ReactNode {\n  const [marketplaceStates, setMarketplaceStates] = useState<\n    MarketplaceState[]\n  >([])\n  const [loading, setLoading] = useState(true)\n  const [selectedIndex, setSelectedIndex] = useState(0)\n  const [isProcessing, setIsProcessing] = useState(false)\n  const [processError, setProcessError] = useState<string | null>(null)\n  const [successMessage, setSuccessMessage] = useState<string | null>(null)\n  const [progressMessage, setProgressMessage] = useState<string | null>(null)\n  const [internalView, setInternalView] = useState<InternalViewState>('list')\n  const [selectedMarketplace, setSelectedMarketplace] =\n    useState<MarketplaceState | null>(null)\n  const [detailsMenuIndex, setDetailsMenuIndex] = useState(0)\n  const hasAttemptedAutoAction = useRef(false)\n\n  // Load marketplaces and their installed plugins\n  useEffect(() => {\n    async function loadMarketplaces() {\n      try {\n        const config = await loadKnownMarketplacesConfig()\n        const { enabled, disabled } = await loadAllPlugins()\n        const allPlugins = [...enabled, ...disabled]\n\n        // Load marketplaces with graceful degradation\n        const { marketplaces, failures } =\n          await loadMarketplacesWithGracefulDegradation(config)\n\n        const states: MarketplaceState[] = []\n        for (const { name, config: entry, data: marketplace } of marketplaces) {\n          // Get all plugins installed from this marketplace\n          const installedFromMarketplace = allPlugins.filter(plugin =>\n            plugin.source.endsWith(`@${name}`),\n          )\n\n          states.push({\n            name,\n            source: getMarketplaceSourceDisplay(entry.source),\n            lastUpdated: entry.lastUpdated,\n            pluginCount: marketplace?.plugins.length,\n            installedPlugins: installedFromMarketplace,\n            pendingUpdate: false,\n            pendingRemove: false,\n            autoUpdate: isMarketplaceAutoUpdate(name, entry),\n          })\n        }\n\n        // Sort: claude-plugin-directory first, then alphabetically\n        states.sort((a, b) => {\n          if (a.name === 'claude-plugin-directory') return -1\n          if (b.name === 'claude-plugin-directory') return 1\n          return a.name.localeCompare(b.name)\n        })\n        setMarketplaceStates(states)\n\n        // Handle marketplace loading errors/warnings\n        const successCount = count(marketplaces, m => m.data !== null)\n        const errorResult = formatMarketplaceLoadingErrors(\n          failures,\n          successCount,\n        )\n        if (errorResult) {\n          if (errorResult.type === 'warning') {\n            setProcessError(errorResult.message)\n          } else {\n            throw new Error(errorResult.message)\n          }\n        }\n\n        // Auto-execute if target and action provided\n        if (targetMarketplace && !hasAttemptedAutoAction.current && !error) {\n          hasAttemptedAutoAction.current = true\n          const targetIndex = states.findIndex(\n            s => s.name === targetMarketplace,\n          )\n          if (targetIndex >= 0) {\n            const targetState = states[targetIndex]\n            if (action) {\n              // Mark the action as pending and execute\n              setSelectedIndex(targetIndex + 1) // +1 because \"Add Marketplace\" is at index 0\n              const newStates = [...states]\n              if (action === 'update') {\n                newStates[targetIndex]!.pendingUpdate = true\n              } else if (action === 'remove') {\n                newStates[targetIndex]!.pendingRemove = true\n              }\n              setMarketplaceStates(newStates)\n              // Apply the change immediately\n              setTimeout(applyChanges, 100, newStates)\n            } else if (targetState) {\n              // No action - just show the details view for this marketplace\n              setSelectedIndex(targetIndex + 1) // +1 because \"Add Marketplace\" is at index 0\n              setSelectedMarketplace(targetState)\n              setInternalView('details')\n            }\n          } else if (setError) {\n            setError(`Marketplace not found: ${targetMarketplace}`)\n          }\n        }\n      } catch (err) {\n        if (setError) {\n          setError(\n            err instanceof Error ? err.message : 'Failed to load marketplaces',\n          )\n        }\n        setProcessError(\n          err instanceof Error ? err.message : 'Failed to load marketplaces',\n        )\n      } finally {\n        setLoading(false)\n      }\n    }\n    void loadMarketplaces()\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    // biome-ignore lint/correctness/useExhaustiveDependencies: intentional\n  }, [targetMarketplace, action, error])\n\n  // Check if there are any pending changes\n  const hasPendingChanges = () => {\n    return marketplaceStates.some(\n      state => state.pendingUpdate || state.pendingRemove,\n    )\n  }\n\n  // Get count of pending operations\n  const getPendingCounts = () => {\n    const updateCount = count(marketplaceStates, s => s.pendingUpdate)\n    const removeCount = count(marketplaceStates, s => s.pendingRemove)\n    return { updateCount, removeCount }\n  }\n\n  // Apply all pending changes\n  const applyChanges = async (states?: MarketplaceState[]) => {\n    const statesToProcess = states || marketplaceStates\n    const wasInDetailsView = internalView === 'details'\n    setIsProcessing(true)\n    setProcessError(null)\n    setSuccessMessage(null)\n    setProgressMessage(null)\n\n    try {\n      const settings = getSettingsForSource('userSettings')\n      let updatedCount = 0\n      let removedCount = 0\n      const refreshedMarketplaces = new Set<string>()\n\n      for (const state of statesToProcess) {\n        // Handle remove\n        if (state.pendingRemove) {\n          // First uninstall all plugins from this marketplace\n          if (state.installedPlugins && state.installedPlugins.length > 0) {\n            const newEnabledPlugins = { ...settings?.enabledPlugins }\n            for (const plugin of state.installedPlugins) {\n              const pluginId = createPluginId(plugin.name, state.name)\n              // Mark as disabled/uninstalled\n              newEnabledPlugins[pluginId] = false\n            }\n            updateSettingsForSource('userSettings', {\n              enabledPlugins: newEnabledPlugins,\n            })\n          }\n\n          // Then remove the marketplace\n          await removeMarketplaceSource(state.name)\n          removedCount++\n\n          logEvent('tengu_marketplace_removed', {\n            marketplace_name:\n              state.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            plugins_uninstalled: state.installedPlugins?.length || 0,\n          })\n          continue\n        }\n\n        // Handle update\n        if (state.pendingUpdate) {\n          // Refresh individual marketplace for efficiency with progress reporting\n          await refreshMarketplace(state.name, (message: string) => {\n            setProgressMessage(message)\n          })\n          updatedCount++\n          refreshedMarketplaces.add(state.name.toLowerCase())\n\n          logEvent('tengu_marketplace_updated', {\n            marketplace_name:\n              state.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          })\n        }\n      }\n\n      // After marketplace clones are refreshed, bump installed plugins from\n      // those marketplaces to the new version. Without this, the loader's\n      // cache-on-miss (copyPluginToVersionedCache) creates the new version\n      // dir on the next loadAllPlugins() call, but installed_plugins.json\n      // stays on the old version — so cleanupOrphanedPluginVersionsInBackground\n      // stamps the NEW dir with .orphaned_at on the next startup. See #29512.\n      // updatePluginOp (called inside the helper) is what actually writes\n      // installed_plugins.json via updateInstallationPathOnDisk.\n      let updatedPluginCount = 0\n      if (refreshedMarketplaces.size > 0) {\n        const updatedPluginIds = await updatePluginsForMarketplaces(\n          refreshedMarketplaces,\n        )\n        updatedPluginCount = updatedPluginIds.length\n      }\n\n      // Clear caches after changes\n      clearAllCaches()\n\n      // Call completion callback\n      if (onManageComplete) {\n        await onManageComplete()\n      }\n\n      // Reload marketplace data to show updated timestamps\n      const config = await loadKnownMarketplacesConfig()\n      const { enabled, disabled } = await loadAllPlugins()\n      const allPlugins = [...enabled, ...disabled]\n\n      const { marketplaces } =\n        await loadMarketplacesWithGracefulDegradation(config)\n\n      const newStates: MarketplaceState[] = []\n      for (const { name, config: entry, data: marketplace } of marketplaces) {\n        const installedFromMarketplace = allPlugins.filter(plugin =>\n          plugin.source.endsWith(`@${name}`),\n        )\n\n        newStates.push({\n          name,\n          source: getMarketplaceSourceDisplay(entry.source),\n          lastUpdated: entry.lastUpdated,\n          pluginCount: marketplace?.plugins.length,\n          installedPlugins: installedFromMarketplace,\n          pendingUpdate: false,\n          pendingRemove: false,\n          autoUpdate: isMarketplaceAutoUpdate(name, entry),\n        })\n      }\n\n      // Sort: claude-plugin-directory first, then alphabetically\n      newStates.sort((a, b) => {\n        if (a.name === 'claude-plugin-directory') return -1\n        if (b.name === 'claude-plugin-directory') return 1\n        return a.name.localeCompare(b.name)\n      })\n      setMarketplaceStates(newStates)\n\n      // Update selected marketplace reference with fresh data\n      if (wasInDetailsView && selectedMarketplace) {\n        const updatedMarketplace = newStates.find(\n          s => s.name === selectedMarketplace.name,\n        )\n        if (updatedMarketplace) {\n          setSelectedMarketplace(updatedMarketplace)\n        }\n      }\n\n      // Build success message\n      const actions: string[] = []\n      if (updatedCount > 0) {\n        const pluginPart =\n          updatedPluginCount > 0\n            ? ` (${updatedPluginCount} ${plural(updatedPluginCount, 'plugin')} bumped)`\n            : ''\n        actions.push(\n          `Updated ${updatedCount} ${plural(updatedCount, 'marketplace')}${pluginPart}`,\n        )\n      }\n      if (removedCount > 0) {\n        actions.push(\n          `Removed ${removedCount} ${plural(removedCount, 'marketplace')}`,\n        )\n      }\n\n      if (actions.length > 0) {\n        const successMsg = `${figures.tick} ${actions.join(', ')}`\n        // If we were in details view, stay there and show success\n        if (wasInDetailsView) {\n          setSuccessMessage(successMsg)\n        } else {\n          // Otherwise show result and exit to menu\n          setResult(successMsg)\n          setTimeout(setViewState, 2000, { type: 'menu' as const })\n        }\n      } else if (!wasInDetailsView) {\n        setViewState({ type: 'menu' })\n      }\n    } catch (err) {\n      const errorMsg = errorMessage(err)\n      setProcessError(errorMsg)\n      if (setError) {\n        setError(errorMsg)\n      }\n    } finally {\n      setIsProcessing(false)\n      setProgressMessage(null)\n    }\n  }\n\n  // Handle confirming marketplace removal\n  const confirmRemove = async () => {\n    if (!selectedMarketplace) return\n\n    // Mark for removal and apply\n    const newStates = marketplaceStates.map(state =>\n      state.name === selectedMarketplace.name\n        ? { ...state, pendingRemove: true }\n        : state,\n    )\n    setMarketplaceStates(newStates)\n    await applyChanges(newStates)\n  }\n\n  // Build menu options for details view\n  const buildDetailsMenuOptions = (\n    marketplace: MarketplaceState | null,\n  ): Array<{ label: string; secondaryLabel?: string; value: string }> => {\n    if (!marketplace) return []\n\n    const options: Array<{\n      label: string\n      secondaryLabel?: string\n      value: string\n    }> = [\n      {\n        label: `Browse plugins (${marketplace.pluginCount ?? 0})`,\n        value: 'browse',\n      },\n      {\n        label: 'Update marketplace',\n        secondaryLabel: marketplace.lastUpdated\n          ? `(last updated ${new Date(marketplace.lastUpdated).toLocaleDateString()})`\n          : undefined,\n        value: 'update',\n      },\n    ]\n\n    // Only show auto-update toggle if auto-updater is not globally disabled\n    if (!shouldSkipPluginAutoupdate()) {\n      options.push({\n        label: marketplace.autoUpdate\n          ? 'Disable auto-update'\n          : 'Enable auto-update',\n        value: 'toggle-auto-update',\n      })\n    }\n\n    options.push({ label: 'Remove marketplace', value: 'remove' })\n\n    return options\n  }\n\n  // Handle toggling auto-update for a marketplace\n  const handleToggleAutoUpdate = async (marketplace: MarketplaceState) => {\n    const newAutoUpdate = !marketplace.autoUpdate\n    try {\n      await setMarketplaceAutoUpdate(marketplace.name, newAutoUpdate)\n\n      // Update local state\n      setMarketplaceStates(prev =>\n        prev.map(state =>\n          state.name === marketplace.name\n            ? { ...state, autoUpdate: newAutoUpdate }\n            : state,\n        ),\n      )\n\n      // Update selected marketplace reference\n      setSelectedMarketplace(prev =>\n        prev ? { ...prev, autoUpdate: newAutoUpdate } : prev,\n      )\n    } catch (err) {\n      setProcessError(\n        err instanceof Error ? err.message : 'Failed to update setting',\n      )\n    }\n  }\n\n  // Escape in details or confirm-remove view - go back to list\n  useKeybinding(\n    'confirm:no',\n    () => {\n      setInternalView('list')\n      setDetailsMenuIndex(0)\n    },\n    {\n      context: 'Confirmation',\n      isActive:\n        !isProcessing &&\n        (internalView === 'details' || internalView === 'confirm-remove'),\n    },\n  )\n\n  // Escape in list view with pending changes - clear pending changes\n  useKeybinding(\n    'confirm:no',\n    () => {\n      setMarketplaceStates(prev =>\n        prev.map(state => ({\n          ...state,\n          pendingUpdate: false,\n          pendingRemove: false,\n        })),\n      )\n      setSelectedIndex(0)\n    },\n    {\n      context: 'Confirmation',\n      isActive: !isProcessing && internalView === 'list' && hasPendingChanges(),\n    },\n  )\n\n  // Escape in list view without pending changes - exit to parent menu\n  useKeybinding(\n    'confirm:no',\n    () => {\n      setViewState({ type: 'menu' })\n    },\n    {\n      context: 'Confirmation',\n      isActive:\n        !isProcessing && internalView === 'list' && !hasPendingChanges(),\n    },\n  )\n\n  // List view — navigation (up/down/enter via configurable keybindings)\n  useKeybindings(\n    {\n      'select:previous': () => setSelectedIndex(prev => Math.max(0, prev - 1)),\n      'select:next': () => {\n        const totalItems = marketplaceStates.length + 1\n        setSelectedIndex(prev => Math.min(totalItems - 1, prev + 1))\n      },\n      'select:accept': () => {\n        const marketplaceIndex = selectedIndex - 1\n        if (selectedIndex === 0) {\n          setViewState({ type: 'add-marketplace' })\n        } else if (hasPendingChanges()) {\n          void applyChanges()\n        } else {\n          const marketplace = marketplaceStates[marketplaceIndex]\n          if (marketplace) {\n            setSelectedMarketplace(marketplace)\n            setInternalView('details')\n            setDetailsMenuIndex(0)\n          }\n        }\n      },\n    },\n    { context: 'Select', isActive: !isProcessing && internalView === 'list' },\n  )\n\n  // List view — marketplace-specific actions (u/r shortcuts)\n  useInput(\n    input => {\n      const marketplaceIndex = selectedIndex - 1\n      if ((input === 'u' || input === 'U') && marketplaceIndex >= 0) {\n        setMarketplaceStates(prev =>\n          prev.map((state, idx) =>\n            idx === marketplaceIndex\n              ? {\n                  ...state,\n                  pendingUpdate: !state.pendingUpdate,\n                  pendingRemove: state.pendingUpdate\n                    ? state.pendingRemove\n                    : false,\n                }\n              : state,\n          ),\n        )\n      } else if ((input === 'r' || input === 'R') && marketplaceIndex >= 0) {\n        const marketplace = marketplaceStates[marketplaceIndex]\n        if (marketplace) {\n          setSelectedMarketplace(marketplace)\n          setInternalView('confirm-remove')\n        }\n      }\n    },\n    { isActive: !isProcessing && internalView === 'list' },\n  )\n\n  // Details view — navigation\n  useKeybindings(\n    {\n      'select:previous': () =>\n        setDetailsMenuIndex(prev => Math.max(0, prev - 1)),\n      'select:next': () => {\n        const menuOptions = buildDetailsMenuOptions(selectedMarketplace)\n        setDetailsMenuIndex(prev => Math.min(menuOptions.length - 1, prev + 1))\n      },\n      'select:accept': () => {\n        if (!selectedMarketplace) return\n        const menuOptions = buildDetailsMenuOptions(selectedMarketplace)\n        const selectedOption = menuOptions[detailsMenuIndex]\n        if (selectedOption?.value === 'browse') {\n          setViewState({\n            type: 'browse-marketplace',\n            targetMarketplace: selectedMarketplace.name,\n          })\n        } else if (selectedOption?.value === 'update') {\n          const newStates = marketplaceStates.map(state =>\n            state.name === selectedMarketplace.name\n              ? { ...state, pendingUpdate: true }\n              : state,\n          )\n          setMarketplaceStates(newStates)\n          void applyChanges(newStates)\n        } else if (selectedOption?.value === 'toggle-auto-update') {\n          void handleToggleAutoUpdate(selectedMarketplace)\n        } else if (selectedOption?.value === 'remove') {\n          setInternalView('confirm-remove')\n        }\n      },\n    },\n    {\n      context: 'Select',\n      isActive: !isProcessing && internalView === 'details',\n    },\n  )\n\n  // Confirm-remove view — y/n input\n  useInput(\n    input => {\n      if (input === 'y' || input === 'Y') {\n        void confirmRemove()\n      } else if (input === 'n' || input === 'N') {\n        setInternalView('list')\n        setSelectedMarketplace(null)\n      }\n    },\n    { isActive: !isProcessing && internalView === 'confirm-remove' },\n  )\n\n  if (loading) {\n    return <Text>Loading marketplaces…</Text>\n  }\n\n  if (marketplaceStates.length === 0) {\n    return (\n      <Box flexDirection=\"column\">\n        <Box marginBottom={1}>\n          <Text bold>Manage marketplaces</Text>\n        </Box>\n\n        {/* Add Marketplace option */}\n        <Box flexDirection=\"row\" gap={1}>\n          <Text color=\"suggestion\">{figures.pointer} +</Text>\n          <Text bold color=\"suggestion\">\n            Add Marketplace\n          </Text>\n        </Box>\n\n        <Box marginLeft={3}>\n          <Text dimColor italic>\n            {exitState.pending ? (\n              <>Press {exitState.keyName} again to go back</>\n            ) : (\n              <Byline>\n                <ConfigurableShortcutHint\n                  action=\"select:accept\"\n                  context=\"Select\"\n                  fallback=\"Enter\"\n                  description=\"select\"\n                />\n                <ConfigurableShortcutHint\n                  action=\"confirm:no\"\n                  context=\"Confirmation\"\n                  fallback=\"Esc\"\n                  description=\"go back\"\n                />\n              </Byline>\n            )}\n          </Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  // Show confirmation dialog\n  if (internalView === 'confirm-remove' && selectedMarketplace) {\n    const pluginCount = selectedMarketplace.installedPlugins?.length || 0\n    return (\n      <Box flexDirection=\"column\">\n        <Text bold color=\"warning\">\n          Remove marketplace <Text italic>{selectedMarketplace.name}</Text>?\n        </Text>\n        <Box flexDirection=\"column\">\n          {pluginCount > 0 && (\n            <Box marginTop={1}>\n              <Text color=\"warning\">\n                This will also uninstall {pluginCount}{' '}\n                {plural(pluginCount, 'plugin')} from this marketplace:\n              </Text>\n            </Box>\n          )}\n          {selectedMarketplace.installedPlugins &&\n            selectedMarketplace.installedPlugins.length > 0 && (\n              <Box flexDirection=\"column\" marginTop={1} marginLeft={2}>\n                {selectedMarketplace.installedPlugins.map(plugin => (\n                  <Text key={plugin.name} dimColor>\n                    • {plugin.name}\n                  </Text>\n                ))}\n              </Box>\n            )}\n          <Box marginTop={1}>\n            <Text>\n              Press <Text bold>y</Text> to confirm or <Text bold>n</Text> to\n              cancel\n            </Text>\n          </Box>\n        </Box>\n      </Box>\n    )\n  }\n\n  // Show marketplace details\n  if (internalView === 'details' && selectedMarketplace) {\n    // Check if this marketplace is currently being processed\n    // Check pendingUpdate first so we show updating state immediately when user presses Enter\n    const isUpdating = selectedMarketplace.pendingUpdate || isProcessing\n\n    const menuOptions = buildDetailsMenuOptions(selectedMarketplace)\n\n    return (\n      <Box flexDirection=\"column\">\n        <Text bold>{selectedMarketplace.name}</Text>\n        <Text dimColor>{selectedMarketplace.source}</Text>\n        <Box marginTop={1}>\n          <Text>\n            {selectedMarketplace.pluginCount || 0} available{' '}\n            {plural(selectedMarketplace.pluginCount || 0, 'plugin')}\n          </Text>\n        </Box>\n\n        {/* Installed plugins section */}\n        {selectedMarketplace.installedPlugins &&\n          selectedMarketplace.installedPlugins.length > 0 && (\n            <Box flexDirection=\"column\" marginTop={1}>\n              <Text bold>\n                Installed plugins ({selectedMarketplace.installedPlugins.length}\n                ):\n              </Text>\n              <Box flexDirection=\"column\" marginLeft={1}>\n                {selectedMarketplace.installedPlugins.map(plugin => (\n                  <Box key={plugin.name} flexDirection=\"row\" gap={1}>\n                    <Text>{figures.bullet}</Text>\n                    <Box flexDirection=\"column\">\n                      <Text>{plugin.name}</Text>\n                      <Text dimColor>{plugin.manifest.description}</Text>\n                    </Box>\n                  </Box>\n                ))}\n              </Box>\n            </Box>\n          )}\n\n        {/* Processing indicator */}\n        {isUpdating && (\n          <Box marginTop={1} flexDirection=\"column\">\n            <Text color=\"claude\">Updating marketplace…</Text>\n            {progressMessage && <Text dimColor>{progressMessage}</Text>}\n          </Box>\n        )}\n\n        {/* Success message */}\n        {!isUpdating && successMessage && (\n          <Box marginTop={1}>\n            <Text color=\"claude\">{successMessage}</Text>\n          </Box>\n        )}\n\n        {/* Error message */}\n        {!isUpdating && processError && (\n          <Box marginTop={1}>\n            <Text color=\"error\">{processError}</Text>\n          </Box>\n        )}\n\n        {/* Menu options */}\n        {!isUpdating && (\n          <Box flexDirection=\"column\" marginTop={1}>\n            {menuOptions.map((option, idx) => {\n              if (!option) return null\n              const isSelected = idx === detailsMenuIndex\n              return (\n                <Box key={option.value}>\n                  <Text color={isSelected ? 'suggestion' : undefined}>\n                    {isSelected ? figures.pointer : ' '} {option.label}\n                  </Text>\n                  {option.secondaryLabel && (\n                    <Text dimColor> {option.secondaryLabel}</Text>\n                  )}\n                </Box>\n              )\n            })}\n          </Box>\n        )}\n\n        {/* Show explanatory text at the bottom when auto-update is enabled */}\n        {!isUpdating &&\n          !shouldSkipPluginAutoupdate() &&\n          selectedMarketplace.autoUpdate && (\n            <Box marginTop={1}>\n              <Text dimColor>\n                Auto-update enabled. Claude Code will automatically update this\n                marketplace and its installed plugins.\n              </Text>\n            </Box>\n          )}\n\n        <Box marginLeft={3}>\n          <Text dimColor italic>\n            {isUpdating ? (\n              <>Please wait…</>\n            ) : (\n              <Byline>\n                <ConfigurableShortcutHint\n                  action=\"select:accept\"\n                  context=\"Select\"\n                  fallback=\"Enter\"\n                  description=\"select\"\n                />\n                <ConfigurableShortcutHint\n                  action=\"confirm:no\"\n                  context=\"Confirmation\"\n                  fallback=\"Esc\"\n                  description=\"go back\"\n                />\n              </Byline>\n            )}\n          </Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  // Show marketplace list\n  const { updateCount, removeCount } = getPendingCounts()\n\n  return (\n    <Box flexDirection=\"column\">\n      <Box marginBottom={1}>\n        <Text bold>Manage marketplaces</Text>\n      </Box>\n\n      {/* Add Marketplace option */}\n      <Box flexDirection=\"row\" gap={1} marginBottom={1}>\n        <Text color={selectedIndex === 0 ? 'suggestion' : undefined}>\n          {selectedIndex === 0 ? figures.pointer : ' '} +\n        </Text>\n        <Text bold color={selectedIndex === 0 ? 'suggestion' : undefined}>\n          Add Marketplace\n        </Text>\n      </Box>\n\n      {/* Marketplace list */}\n      <Box flexDirection=\"column\">\n        {marketplaceStates.map((state, idx) => {\n          const isSelected = idx + 1 === selectedIndex // +1 because Add Marketplace is at index 0\n\n          // Build status indicators\n          const indicators: string[] = []\n          if (state.pendingUpdate) indicators.push('UPDATE')\n          if (state.pendingRemove) indicators.push('REMOVE')\n\n          return (\n            <Box key={state.name} flexDirection=\"row\" gap={1} marginBottom={1}>\n              <Text color={isSelected ? 'suggestion' : undefined}>\n                {isSelected ? figures.pointer : ' '}{' '}\n                {state.pendingRemove ? figures.cross : figures.bullet}\n              </Text>\n              <Box flexDirection=\"column\" flexGrow={1}>\n                <Box flexDirection=\"row\" gap={1}>\n                  <Text\n                    bold\n                    strikethrough={state.pendingRemove}\n                    dimColor={state.pendingRemove}\n                  >\n                    {state.name === 'claude-plugins-official' && (\n                      <Text color=\"claude\">✻ </Text>\n                    )}\n                    {state.name}\n                    {state.name === 'claude-plugins-official' && (\n                      <Text color=\"claude\"> ✻</Text>\n                    )}\n                  </Text>\n                  {indicators.length > 0 && (\n                    <Text color=\"warning\">[{indicators.join(', ')}]</Text>\n                  )}\n                </Box>\n                <Text dimColor>{state.source}</Text>\n                <Text dimColor>\n                  {state.pluginCount !== undefined && (\n                    <>{state.pluginCount} available</>\n                  )}\n                  {state.installedPlugins &&\n                    state.installedPlugins.length > 0 && (\n                      <> • {state.installedPlugins.length} installed</>\n                    )}\n                  {state.lastUpdated && (\n                    <>\n                      {' '}\n                      • Updated{' '}\n                      {new Date(state.lastUpdated).toLocaleDateString()}\n                    </>\n                  )}\n                </Text>\n              </Box>\n            </Box>\n          )\n        })}\n      </Box>\n\n      {/* Pending changes summary */}\n      {hasPendingChanges() && (\n        <Box marginTop={1} flexDirection=\"column\">\n          <Text>\n            <Text bold>Pending changes:</Text>{' '}\n            <Text dimColor>Enter to apply</Text>\n          </Text>\n          {updateCount > 0 && (\n            <Text>\n              • Update {updateCount} {plural(updateCount, 'marketplace')}\n            </Text>\n          )}\n          {removeCount > 0 && (\n            <Text color=\"warning\">\n              • Remove {removeCount} {plural(removeCount, 'marketplace')}\n            </Text>\n          )}\n        </Box>\n      )}\n\n      {/* Processing indicator */}\n      {isProcessing && (\n        <Box marginTop={1}>\n          <Text color=\"claude\">Processing changes…</Text>\n        </Box>\n      )}\n\n      {/* Error display */}\n      {processError && (\n        <Box marginTop={1}>\n          <Text color=\"error\">{processError}</Text>\n        </Box>\n      )}\n\n      <ManageMarketplacesKeyHints\n        exitState={exitState}\n        hasPendingActions={hasPendingChanges()}\n      />\n    </Box>\n  )\n}\n\ntype ManageMarketplacesKeyHintsProps = {\n  exitState: Props['exitState']\n  hasPendingActions: boolean\n}\n\nfunction ManageMarketplacesKeyHints({\n  exitState,\n  hasPendingActions,\n}: ManageMarketplacesKeyHintsProps): React.ReactNode {\n  if (exitState.pending) {\n    return (\n      <Box marginTop={1}>\n        <Text dimColor italic>\n          Press {exitState.keyName} again to go back\n        </Text>\n      </Box>\n    )\n  }\n\n  return (\n    <Box marginTop={1}>\n      <Text dimColor italic>\n        <Byline>\n          {hasPendingActions && (\n            <ConfigurableShortcutHint\n              action=\"select:accept\"\n              context=\"Select\"\n              fallback=\"Enter\"\n              description=\"apply changes\"\n            />\n          )}\n          {!hasPendingActions && (\n            <ConfigurableShortcutHint\n              action=\"select:accept\"\n              context=\"Select\"\n              fallback=\"Enter\"\n              description=\"select\"\n            />\n          )}\n          {!hasPendingActions && (\n            <KeyboardShortcutHint shortcut=\"u\" action=\"update\" />\n          )}\n          {!hasPendingActions && (\n            <KeyboardShortcutHint shortcut=\"r\" action=\"remove\" />\n          )}\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Confirmation\"\n            fallback=\"Esc\"\n            description={hasPendingActions ? 'cancel' : 'go back'}\n          />\n        </Byline>\n      </Text>\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}