.mcpd.toml stores required env and args (#55)

Author: peteski22

cmd/add.go

@@ -47,8 +47,10 @@ func NewAddCmd(baseCmd *cmd.BaseCmd, opt ...cmdopts.CmdOption) (*cobra.Command,
 	cobraCommand := &cobra.Command{
 		Use:   "add <server-name>",
 		Short: "Adds an MCP server dependency to the project.",
-		Long:  c.longDescription(),
-		RunE:  c.run,
+		Long: `Adds an MCP server dependency to the project. 
+mcpd will search the registry for the named server and attempt to return information on the version specified, 
+or 'latest' if no version specified.`,
+		RunE: c.run,
 	}
 
 	cobraCommand.Flags().StringVar(
@@ -82,13 +84,6 @@ func NewAddCmd(baseCmd *cmd.BaseCmd, opt ...cmdopts.CmdOption) (*cobra.Command,
 	return cobraCommand, nil
 }
 
-// longDescription returns the long version of the command description.
-func (c *AddCmd) longDescription() string {
-	return `Adds an MCP server dependency to the project. 
-mcpd will search the registry for the server and attempt to return information on the version specified, 
-or 'latest' if no version specified.`
-}
-
 // 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 {
@@ -97,9 +92,6 @@ func (c *AddCmd) run(cmd *cobra.Command, args []string) error {
 	}
 
 	name := strings.TrimSpace(args[0])
-	if name == "" {
-		return fmt.Errorf("server name cannot be empty")
-	}
 
 	logger, err := c.Logger()
 	if err != nil {
@@ -151,7 +143,13 @@ func (c *AddCmd) run(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
-	logger.Debug("Server added", "name", name, "version", entry.PackageVersion(), "tools", entry.Tools)
+	logger.Debug(
+		"Server added",
+		"name", name,
+		"package", entry.Package,
+		"version", entry.PackageVersion(),
+		"tools", entry.Tools,
+	)
 
 	// Print the package info.
 	if err = c.packagePrinter.PrintPackage(pkg); err != nil {
@@ -228,10 +226,15 @@ func parseServerEntry(
 	}
 	runtimePackageVersion := fmt.Sprintf("%s::%s@%s", selectedRuntime, runtimeSpecificName, v)
 
+	envs := packages.FilterArguments(pkg.Arguments, packages.EnvVar, packages.Required)
+	args := packages.FilterArguments(pkg.Arguments, packages.Argument, packages.Required)
+
 	return config.ServerEntry{
-		Name:    pkg.ID,
-		Package: runtimePackageVersion,
-		Tools:   requestedTools,
+		Name:            pkg.ID,
+		Package:         runtimePackageVersion,
+		Tools:           requestedTools,
+		RequiredArgs:    args.Names(),
+		RequiredEnvVars: envs.Names(),
 	}, nil
 }
 

internal/config/types.go

@@ -1,6 +1,8 @@
 package config
 
-import "strings"
+import (
+	"strings"
+)
 
 var (
 	_ Provider = (*DefaultLoader)(nil)
@@ -47,6 +49,12 @@ type ServerEntry struct {
 	// Tools lists the names of the tools which should be allowed on this server.
 	// e.g. 'create_repository'
 	Tools []string `toml:"tools"`
+
+	// RequiredEnvVars captures any environment variables required to run the server.
+	RequiredEnvVars []string `toml:"required_env,omitempty"`
+
+	// RequiredArgs captures any command line args required to run the server.
+	RequiredArgs []string `toml:"required_args,omitempty"`
 }
 
 type serverKey struct {

internal/packages/argument.go

@@ -1,7 +1,9 @@
 package packages
 
 import (
+	"maps"
 	"regexp"
+	"slices"
 )
 
 const (
@@ -27,51 +29,44 @@ type ArgumentMetadata struct {
 	VariableType VariableType `json:"type"`
 }
 
-func (a *Arguments) byVariableType(vt VariableType) map[string]ArgumentMetadata {
-	args := *a
-	result := make(map[string]ArgumentMetadata, len(args))
-	for name, arg := range args {
-		if arg.VariableType == vt {
-			result[name] = arg
-		}
-	}
-	return result
+// FilterBy allows filtering of Arguments using predicates.
+// All predicates must be true in order for an argument to be included in the results.
+func (a Arguments) FilterBy(predicate ...func(name string, data ArgumentMetadata) bool) Arguments {
+	return FilterArguments(a, predicate...)
 }
 
-func (a *Arguments) EnvVars() Arguments {
-	return a.byVariableType(VariableTypeEnv)
+// Names returns the names of the Arguments.
+func (a Arguments) Names() []string {
+	return slices.Collect(maps.Keys(a))
 }
 
-func (a *Arguments) EnvVarNames() []string {
-	var ns []string
-	for k, v := range *a {
-		if v.IsEnvironmentVariable() {
-			ns = append(ns, k)
+// FilterArguments allows Arguments to be filtered using any number of predicates.
+// All predicates must be true in order for an argument to be included in the results.
+func FilterArguments(args Arguments, predicate ...func(name string, data ArgumentMetadata) bool) Arguments {
+	result := make(Arguments)
+next:
+	for name, arg := range args {
+		for _, p := range predicate {
+			if !p(name, arg) {
+				continue next
+			}
 		}
+		result[name] = arg
 	}
-	return ns
-}
-
-func (a *Arguments) Args() Arguments {
-	return a.byVariableType(VariableTypeArg)
+	return result
 }
 
-func (a *Arguments) ArgNames() []string {
-	var ns []string
-	for k, v := range *a {
-		if v.IsCommandLineArgument() {
-			ns = append(ns, k)
-		}
-	}
-	return ns
+// Required is a predicate that requires the argument is required.
+func Required(_ string, data ArgumentMetadata) bool {
+	return data.Required
 }
 
-// IsEnvironmentVariable returns true if this argument is primarily used as an environment variable
-func (am ArgumentMetadata) IsEnvironmentVariable() bool {
-	return am.VariableType == VariableTypeEnv
+// EnvVar is a predicate that requires the argument is an environment variable.
+func EnvVar(_ string, data ArgumentMetadata) bool {
+	return data.VariableType == VariableTypeEnv
 }
 
-// IsCommandLineArgument returns true if this argument is primarily used as a command line argument
-func (am ArgumentMetadata) IsCommandLineArgument() bool {
-	return am.VariableType == VariableTypeArg
+// Argument is a predicate that requires the argument is a command line argument.
+func Argument(_ string, data ArgumentMetadata) bool {
+	return data.VariableType == VariableTypeArg
 }