add selection to various mcp commands (#4415)

* add selection to various mcp commands

* fix mcp destroy config

Author: rubys

internal/command/mcp/config.go

@@ -322,6 +322,169 @@ func ListConfigPaths(ctx context.Context, configIsArray bool) ([]ConfigPath, err
 	return paths, nil
 }
 
+func ServerMap(configPaths []ConfigPath) (map[string]any, error) {
+	// build a server map from all of the configs
+	serverMap := make(map[string]any)
+
+	for _, configPath := range configPaths {
+		// if the configuration file doesn't exist, skip it
+		if _, err := os.Stat(configPath.Path); err != nil {
+			if os.IsNotExist(err) {
+				continue
+			}
+			return nil, err
+		}
+
+		// read the configuration file
+		file, err := os.Open(configPath.Path)
+		if err != nil {
+			return nil, err
+		}
+		defer file.Close()
+
+		// parse the configuration file as JSON
+		var data map[string]any
+		decoder := json.NewDecoder(file)
+		if err := decoder.Decode(&data); err != nil {
+			return nil, fmt.Errorf("failed to parse %s: %w", configPath.Path, err)
+		}
+
+		if mcpServers, ok := data[configPath.ConfigName].(map[string]any); ok {
+			// add metadata about the tool
+			config := make(map[string]any)
+			config["mcpServers"] = mcpServers
+			config["configName"] = configPath.ConfigName
+
+			if configPath.ToolName != "" {
+				config["toolName"] = configPath.ToolName
+			}
+
+			serverMap[configPath.Path] = config
+
+			// add metadata about each MCP server
+			for name := range mcpServers {
+				if serverMap, ok := mcpServers[name].(map[string]any); ok {
+					server, err := configExtract(configPath, name)
+					if err != nil {
+						return nil, fmt.Errorf("failed to extract config for %s: %w", name, err)
+					}
+
+					for key, value := range server {
+						if key != "command" && key != "args" {
+							serverMap[key] = value
+						}
+					}
+
+					mcpServers[name] = serverMap
+				}
+			}
+		}
+	}
+
+	return serverMap, nil
+}
+
+func SelectServerAndConfig(ctx context.Context, configIsArray bool) (string, []ConfigPath, error) {
+	server := flag.GetString(ctx, "server")
+
+	// Check if the user has specified any client flags
+	configSelected := false
+	for client := range McpClients {
+		configSelected = configSelected || flag.GetBool(ctx, client)
+	}
+
+	// if no cllent is selected, select all clients
+	if !configSelected {
+		for client := range McpClients {
+			flag.SetString(ctx, client, "true")
+		}
+	}
+
+	// Get a list of config paths
+	configPaths, err := ListConfigPaths(ctx, true)
+	if err != nil {
+		return "", nil, err
+	}
+
+	var serverMap map[string]any
+
+	if len(configPaths) > 1 || server == "" {
+		serverMap, err = ServerMap(configPaths)
+		if err != nil {
+			return "", nil, fmt.Errorf("failed to get server map: %w", err)
+		}
+	}
+
+	if len(configPaths) == 0 {
+		return "", nil, errors.New("no configuration paths found")
+	} else if len(configPaths) > 1 && !configIsArray {
+		choices := make([]string, 0)
+		choiceMap := make(map[int]int)
+		for i, configPath := range configPaths {
+			if config, ok := serverMap[configPath.Path].(map[string]any); ok {
+				if servers, ok := config["mcpServers"].(map[string]any); ok && len(servers) > 0 {
+					if toolName, ok := config["toolName"].(string); ok {
+						choices = append(choices, toolName)
+					} else {
+						choices = append(choices, configPath.Path)
+					}
+					choiceMap[i] = len(choices) - 1
+				}
+			}
+		}
+
+		index := 0
+		if len(choices) == 0 {
+			return "", nil, errors.New("no MCP servers found in the selected configuration files")
+		} else if len(choices) > 1 {
+			err := prompt.Select(ctx, &index, "Select a configuration file", "", choices...)
+			if err != nil {
+				return "", nil, fmt.Errorf("failed to select configuration file: %w", err)
+			}
+			if choiceIndex, ok := choiceMap[index]; ok {
+				index = choiceIndex
+			}
+
+		}
+
+		configPaths = []ConfigPath{configPaths[index]}
+	}
+
+	if server == "" {
+		if len(serverMap) == 0 {
+			return "", configPaths, errors.New("no MCP servers found in the selected configuration files")
+		}
+		// Select a server from the server map
+		var index int
+		choices := make([]string, 0)
+		for _, configPath := range serverMap {
+			if config, ok := configPath.(map[string]any); ok {
+				if servers, ok := config["mcpServers"].(map[string]any); ok {
+					for name := range servers {
+						choices = append(choices, name)
+					}
+				}
+			}
+		}
+
+		if len(choices) == 0 {
+			return "", configPaths, errors.New("no MCP servers found in the selected configuration files")
+		} else if len(choices) == 1 {
+			server = choices[0]
+			log.Debugf("Only one MCP server found: %s", server)
+		} else {
+			err := prompt.Select(ctx, &index, "Select a MCP server", "", choices...)
+			if err != nil {
+				return "", configPaths, fmt.Errorf("failed to select MCP server: %w", err)
+			}
+			server = choices[index]
+			log.Debugf("Selected MCP server: %s", server)
+		}
+	}
+
+	return server, configPaths, nil
+}
+
 // UpdateConfig updates the configuration at the specified path with the MCP servers
 func UpdateConfig(ctx context.Context, path string, configKey string, server string, command string, args []string) error {
 	log.Debugf("Updating configuration at %s", path)
@@ -413,32 +576,9 @@ func UpdateConfig(ctx context.Context, path string, configKey string, server str
 func runRemove(ctx context.Context) error {
 	var err error
 
-	configPaths, err := ListConfigPaths(ctx, true)
+	server, configPaths, err := SelectServerAndConfig(ctx, false)
 	if err != nil {
 		return err
-	} else if len(configPaths) == 0 {
-		return errors.New("no configuration paths found")
-	}
-
-	server := flag.GetString(ctx, "server")
-	if server == "" {
-		server = flag.GetString(ctx, "name")
-		if server == "" {
-			appConfig := appconfig.ConfigFromContext(ctx)
-			if appConfig == nil {
-				appName := appconfig.NameFromContext(ctx)
-				if appName == "" {
-					return errors.New("app name is required")
-				} else {
-					appConfig, err = appconfig.FromRemoteApp(ctx, appName)
-					if err != nil {
-						return err
-					}
-				}
-			}
-
-			server = appConfig.AppName
-		}
 	}
 
 	for _, configPath := range configPaths {

internal/command/mcp/destroy.go

@@ -30,7 +30,7 @@ func NewDestroy() *cobra.Command {
 			Name:        "server",
 			Description: "Name of the MCP server in the MCP client configuration",
 		},
-		flag.String{
+		flag.StringArray{
 			Name:        "config",
 			Description: "Path to the MCP client configuration file",
 		},
@@ -57,9 +57,7 @@ func runDestroy(ctx context.Context) error {
 	appName := appconfig.NameFromContext(ctx)
 
 	if appName == "" {
-		server := flag.GetString(ctx, "server")
-
-		configPaths, err := ListConfigPaths(ctx, true)
+		server, configPaths, err := SelectServerAndConfig(ctx, true)
 		if err != nil {
 			return err
 		}
@@ -104,7 +102,7 @@ func runDestroy(ctx context.Context) error {
 
 	args = []string{}
 
-	// Add the MCP server to the MCP client configurations
+	// Remove the MCP server to the MCP client configurations
 	for client := range McpClients {
 		if flag.GetBool(ctx, client) {
 			args = append(args, "--"+client)
@@ -113,7 +111,7 @@ func runDestroy(ctx context.Context) error {
 
 	for _, config := range flag.GetStringArray(ctx, "config") {
 		if config != "" {
-			log.Debugf("Adding %s to MCP client configuration", config)
+			log.Debugf("Removing %s from the MCP client configuration", config)
 			args = append(args, "--config", config)
 		}
 	}

internal/command/mcp/logs.go

@@ -53,31 +53,18 @@ func newLogs() *cobra.Command {
 }
 
 func runLogs(ctx context.Context) error {
-	// Get a list of config paths
-	configPaths, err := ListConfigPaths(ctx, true)
+	name, configPaths, err := SelectServerAndConfig(ctx, false)
 	if err != nil {
 		return err
 	}
 
-	if len(configPaths) == 0 {
-		return fmt.Errorf("no MCP client configuration files found")
-	} else if len(configPaths) > 1 {
-		return fmt.Errorf("multiple MCP client configuration files found, please specify one")
-	}
-
-	// Get the server name
-	name := flag.GetString(ctx, "server")
-	if name == "" {
-		return fmt.Errorf("please specify a server name")
-	}
-
 	server, err := configExtract(configPaths[0], name)
 	if err != nil {
 		return err
 	}
 
-	if app, ok := server["app"]; ok {
-		args := []string{"logs", "--app", app.(string)}
+	if app, ok := server["app"].(string); ok {
+		args := []string{"logs", "--app", app}
 
 		if flag.GetBool(ctx, "json") {
 			args = append(args, "--json")

internal/command/mcp/proxy.go

@@ -154,9 +154,7 @@ func runProxy(ctx context.Context) error {
 func runInspect(ctx context.Context) error {
 	proxyInfo := getInfo(ctx)
 
-	server := flag.GetString(ctx, "server")
-
-	configPaths, err := ListConfigPaths(ctx, true)
+	server, configPaths, err := SelectServerAndConfig(ctx, false)
 	if err != nil {
 		return err
 	}