Add optional flag to mcpd add to --allow-deprecatd (#134)

* Allows server installations marked as deprecated to be added to mcpd config, without it they are rejected.

Author: peteski22

cmd/add.go

@@ -28,6 +28,7 @@ type AddCmd struct {
 	Runtime         string
 	Source          string
 	Format          internalcmd.OutputFormat
+	AllowDeprecated bool
 	cfgLoader       config.Loader
 	packagePrinter  output.Printer[config.ServerEntry]
 	registryBuilder registry.Builder
@@ -92,9 +93,24 @@ func NewAddCmd(baseCmd *internalcmd.BaseCmd, opt ...cmdopts.CmdOption) (*cobra.C
 		fmt.Sprintf("Specify the output format (one of: %s)", allowed.String()),
 	)
 
+	cobraCommand.Flags().BoolVar(
+		&c.AllowDeprecated,
+		"allow-deprecated",
+		false,
+		"Optional, allows server installations marked as deprecated to be added",
+	)
+
 	return cobraCommand, nil
 }
 
+// serverEntryOptions contains configuration for parsing a server entry
+type serverEntryOptions struct {
+	Runtime           runtime.Runtime
+	Tools             []string
+	SupportedRuntimes []runtime.Runtime
+	AllowDeprecated   bool
+}
+
 // run is configured (via NewAddCmd) to be called by the Cobra framework when the command is executed.
 // It may return an error (or nil, when there is no error).
 func (c *AddCmd) run(cmd *cobra.Command, args []string) error {
@@ -138,9 +154,15 @@ func (c *AddCmd) run(cmd *cobra.Command, args []string) error {
 		)
 	}
 
-	entry, err := parseServerEntry(pkg, runtime.Runtime(c.Runtime), c.Tools, c.MCPDSupportedRuntimes())
+	opts := serverEntryOptions{
+		Runtime:           runtime.Runtime(c.Runtime),
+		Tools:             c.Tools,
+		SupportedRuntimes: c.MCPDSupportedRuntimes(),
+		AllowDeprecated:   c.AllowDeprecated,
+	}
+	entry, err := parseServerEntry(pkg, opts)
 	if err != nil {
-		return handler.HandleError(fmt.Errorf("error parsing server entry: %w", err))
+		return handler.HandleError(err)
 	}
 
 	cfg, err := c.cfgLoader.Load(flags.ConfigFile)
@@ -208,39 +230,49 @@ func selectRuntime(
 	return "", fmt.Errorf("no supported runtimes found")
 }
 
-func parseServerEntry(
-	pkg packages.Server,
-	requestedRuntime runtime.Runtime,
-	requestedTools []string,
-	supportedRuntimes []runtime.Runtime,
-) (config.ServerEntry, error) {
-	requestedTools, err := filter.MatchRequestedSlice(requestedTools, pkg.Tools.Names())
+func parseServerEntry(pkg packages.Server, opts serverEntryOptions) (config.ServerEntry, error) {
+	requestedTools, err := filter.MatchRequestedSlice(opts.Tools, pkg.Tools.Names())
 	if err != nil {
 		return config.ServerEntry{}, fmt.Errorf("error matching requested tools: %w", err)
 	}
 
-	selectedRuntime, runtimeErr := selectRuntime(pkg.Installations, requestedRuntime, supportedRuntimes)
-	if runtimeErr != nil {
-		return config.ServerEntry{}, fmt.Errorf("error selecting runtime from available installations: %w", runtimeErr)
+	selectedRuntime, err := selectRuntime(pkg.Installations, opts.Runtime, opts.SupportedRuntimes)
+	if err != nil {
+		return config.ServerEntry{}, fmt.Errorf("error selecting runtime from available installations: %w", err)
+	}
+
+	installation, ok := pkg.Installations[selectedRuntime]
+	if !ok {
+		return config.ServerEntry{}, fmt.Errorf(
+			"installation not found for runtime '%s'",
+			selectedRuntime,
+		)
 	}
 
-	v := "latest"
-	if installation, ok := pkg.Installations[selectedRuntime]; ok && installation.Version != "" {
-		v = installation.Version
+	if installation.Deprecated && !opts.AllowDeprecated {
+		return config.ServerEntry{}, fmt.Errorf(
+			"server '%s' with runtime '%s' is deprecated, use --allow-deprecated flag to proceed",
+			pkg.ID,
+			selectedRuntime,
+		)
 	}
 
-	runtimeSpecificName := pkg.Installations[selectedRuntime].Package
-	if runtimeSpecificName == "" {
+	if installation.Package == "" {
 		return config.ServerEntry{}, fmt.Errorf(
 			"installation package name is missing for runtime '%s'",
 			selectedRuntime,
 		)
 	}
-	runtimePackageVersion := fmt.Sprintf("%s::%s@%s", selectedRuntime, runtimeSpecificName, v)
 
-	envs := packages.FilterArguments(pkg.Arguments, packages.EnvVar, packages.Required)
-	args := packages.FilterArguments(pkg.Arguments, packages.ValueArgument, packages.Required)
-	boolArgs := packages.FilterArguments(pkg.Arguments, packages.BoolArgument, packages.Required)
+	version := "latest"
+	if installation.Version != "" {
+		version = installation.Version
+	}
+
+	runtimePackageVersion := fmt.Sprintf("%s::%s@%s", selectedRuntime, installation.Package, version)
+	envs := pkg.Arguments.FilterBy(packages.Required, packages.EnvVar)
+	args := pkg.Arguments.FilterBy(packages.Required, packages.ValueAcceptingArgument)
+	boolArgs := pkg.Arguments.FilterBy(packages.Required, packages.BoolArgument)
 
 	return config.ServerEntry{
 		Name:              pkg.ID,

cmd/add_test.go

@@ -411,6 +411,10 @@ func TestSelectRuntime(t *testing.T) {
 	}
 }
 
+func intPtr(i int) *int {
+	return &i
+}
+
 func TestParseServerEntry(t *testing.T) {
 	t.Parallel()
 
@@ -515,6 +519,28 @@ func TestParseServerEntry(t *testing.T) {
 			expectedPackageValue:   "uvx::mcp-server-api@latest",
 			expectedRequiredValues: []string{"--endpoint", "--api-key"},
 		},
+		{
+			name: "server with positional and value args",
+			installations: map[runtime.Runtime]packages.Installation{
+				runtime.UVX: {
+					Package:     "mcp-server-files",
+					Recommended: true,
+				},
+			},
+			supportedRuntimes: []runtime.Runtime{runtime.UVX},
+			pkgName:           "files",
+			pkgID:             "files",
+			availableTools:    []string{"read", "write"},
+			requestedTools:    []string{"read"},
+			arguments: packages.Arguments{
+				"path":       {VariableType: packages.VariableTypeArgPositional, Position: intPtr(1), Required: true},
+				"mode":       {VariableType: packages.VariableTypeArgPositional, Position: intPtr(2), Required: true},
+				"--format":   {VariableType: packages.VariableTypeArg, Required: true},
+				"--encoding": {VariableType: packages.VariableTypeArg, Required: false},
+			},
+			expectedPackageValue:   "uvx::mcp-server-files@latest",
+			expectedRequiredValues: []string{"path", "mode", "--format"},
+		},
 		{
 			name: "server with only required bool args",
 			installations: map[runtime.Runtime]packages.Installation{
@@ -626,7 +652,13 @@ func TestParseServerEntry(t *testing.T) {
 				Arguments:     tc.arguments,
 			}
 
-			entry, err := parseServerEntry(pkg, tc.requestedRuntime, tc.requestedTools, tc.supportedRuntimes)
+			opts := serverEntryOptions{
+				Runtime:           tc.requestedRuntime,
+				Tools:             tc.requestedTools,
+				SupportedRuntimes: tc.supportedRuntimes,
+				AllowDeprecated:   false,
+			}
+			entry, err := parseServerEntry(pkg, opts)
 
 			if tc.isErrorExpected {
 				require.Error(t, err)

internal/packages/argument.go

@@ -146,5 +146,11 @@ func PositionalArgument(_ string, data ArgumentMetadata) bool {
 
 // NonPositionalArgument is a predicate that requires the argument is not a positional command line argument.
 func NonPositionalArgument(s string, data ArgumentMetadata) bool {
-	return !PositionalArgument(s, data)
+	return !PositionalArgument(s, data) && !EnvVar(s, data)
+}
+
+// ValueAcceptingArgument is a predicate that requires an argument is capable of accepting a value.
+// This means it must be an argument (as opposed to env var) and cannot be a boolean flag.
+func ValueAcceptingArgument(_ string, data ArgumentMetadata) bool {
+	return data.VariableType == VariableTypeArgPositional || data.VariableType == VariableTypeArg
 }