fix: Named arguments should identify the argument name (#321)

Originally by @dmartinol. This branch is an attempt by @domdomegg to fix
the merge conflicts...

---

## Motivation and Context
Closes #145 

Add comprehensive validation for named arguments in MCP server packages
to ensure argument names, values, and defaults follow proper format
conventions. This prevents common issues where argument names contain
embedded values or descriptions, and where values/defaults incorrectly
start with the argument name itself.

Key changes:
- Add ArgumentValidator with validation rules for named argument format
- Enhance PackageValidator to validate runtime and package arguments
- Update import process to log warnings for invalid servers instead of
failing
- Fix 396 servers in seed.json with malformed named arguments
- Extended `validate-examples` tool to apply the object validator (it
was completely missed before)
- Add comprehensive test coverage for all validation scenarios

Examples of fixes applied:
- "--directory <path>" → "--directory" with value "<path>"
- "--with-editable $REPO" → "--with-editable" with value "$REPO"
- "recipient@example.com" → "--recipient" (proper argument naming)

All servers now pass validation during both API publishing and data
import.

🤖 Generated with [Claude Code](https://claude.ai/code)

## How Has This Been Tested?
With ad-hoc unit tests.
Manual integration tests of built artifact and the seed data.

## Breaking Changes
New registrations need to follow the argument name conventions,
otherwise the import would fail for the inconsistent servers.

## Types of changes
- [x] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update

## Checklist
- [x] I have read the [MCP
Documentation](https://modelcontextprotocol.io)
- [x] My code follows the repository's style guidelines
- [x] New and existing tests pass locally
- [x] I have added appropriate error handling
- [ ] I have added or updated documentation as needed

---------

Signed-off-by: Daniele Martinoli <dmartino@redhat.com>
Co-authored-by: Daniele Martinoli <dmartino@redhat.com>
Co-authored-by: Claude <noreply@anthropic.com>

Author: 3 people

data/seed.json

@@ -5,10 +5,12 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"log"
 	"net/http"
 	"os"
 	"strings"
 
+	"github.com/modelcontextprotocol/registry/internal/validators"
 	apiv0 "github.com/modelcontextprotocol/registry/pkg/api/v0"
 )
 
@@ -48,14 +50,37 @@ func ReadSeedFile(ctx context.Context, path string) ([]*apiv0.ServerRecord, erro
 		return []*apiv0.ServerRecord{}, nil
 	}
 
-	// Convert ServerResponse to ServerRecord
-	var records []*apiv0.ServerRecord
+	// Validate servers and collect warnings instead of failing the whole batch
+	var validRecords []*apiv0.ServerRecord
+	var invalidServers []string
+	var validationFailures []string
+
 	for _, response := range serverResponses {
+		if err := validators.ValidateServerJSON(&response.Server); err != nil {
+			// Log warning and track invalid server instead of failing
+			invalidServers = append(invalidServers, response.Server.Name)
+			validationFailures = append(validationFailures, fmt.Sprintf("Server '%s': %v", response.Server.Name, err))
+			log.Printf("Warning: Skipping invalid server '%s': %v", response.Server.Name, err)
+			continue
+		}
+
+		// Convert valid ServerResponse to ServerRecord
 		record := convertServerResponseToRecord(response)
-		records = append(records, record)
+		validRecords = append(validRecords, record)
+	}
+
+	// Print summary of validation results
+	if len(invalidServers) > 0 {
+		log.Printf("Import summary: %d valid servers imported, %d invalid servers skipped", len(validRecords), len(invalidServers))
+		log.Printf("Invalid servers: %v", invalidServers)
+		for _, failure := range validationFailures {
+			log.Printf("  - %s", failure)
+		}
+	} else {
+		log.Printf("Import summary: All %d servers imported successfully", len(validRecords))
 	}
 
-	return records, nil
+	return validRecords, nil
 }
 
 func fetchFromHTTP(ctx context.Context, url string) ([]byte, error) {

internal/database/import.go

@@ -21,7 +21,7 @@ func TestReadSeedFile_LocalFile(t *testing.T) {
 	seedData := []apiv0.ServerRecord{
 		{
 			Server: model.ServerJSON{
-				Name:        "test-server-1",
+				Name:        "com.example/test-server-1",
 				Description: "Test server 1",
 				Repository: model.Repository{
 					URL:    "https://github.com/test/repo1",
@@ -31,6 +31,11 @@ func TestReadSeedFile_LocalFile(t *testing.T) {
 				VersionDetail: model.VersionDetail{
 					Version: "1.0.0",
 				},
+				Remotes: []model.Remote{
+					{
+						URL: "https://example.com/remote",
+					},
+				},
 			},
 			XIOModelContextProtocolRegistry: apiv0.RegistryExtensions{
 				ID:          "test-id-1",
@@ -61,16 +66,21 @@ func TestReadSeedFile_LocalFile(t *testing.T) {
 	result, err := database.ReadSeedFile(context.Background(), tempFile)
 	assert.NoError(t, err)
 	assert.Len(t, result, 1)
-	assert.Equal(t, "test-server-1", result[0].Server.Name)
+	assert.Equal(t, "com.example/test-server-1", result[0].Server.Name)
 }
 
 func TestReadSeedFile_DirectHTTPURL(t *testing.T) {
 	// Create a test HTTP server that serves seed JSON directly in extension wrapper format
 	seedData := []apiv0.ServerRecord{
 		{
 			Server: model.ServerJSON{
-				Name:        "test-server-1",
+				Name:        "com.example/test-server-1",
 				Description: "Test server 1",
+				Remotes: []model.Remote{
+					{
+						URL: "https://example.com/remote",
+					},
+				},
 			},
 			XIOModelContextProtocolRegistry: apiv0.RegistryExtensions{
 				ID:          "test-id-1",
@@ -93,7 +103,7 @@ func TestReadSeedFile_DirectHTTPURL(t *testing.T) {
 	result, err := database.ReadSeedFile(context.Background(), server.URL+"/seed.json")
 	assert.NoError(t, err)
 	assert.Len(t, result, 1)
-	assert.Equal(t, "test-server-1", result[0].Server.Name)
+	assert.Equal(t, "com.example/test-server-1", result[0].Server.Name)
 }
 
 func TestReadSeedFile_RegistryURL(t *testing.T) {

internal/database/import_test.go

@@ -12,6 +12,12 @@ var (
 
 	// Remote validation errors
 	ErrInvalidRemoteURL = errors.New("invalid remote URL")
+
+	// Argument validation errors
+	ErrNamedArgumentNameRequired    = errors.New("named argument name is required")
+	ErrInvalidNamedArgumentName     = errors.New("invalid named argument name format")
+	ErrArgumentValueStartsWithName  = errors.New("argument value cannot start with the argument name")
+	ErrArgumentDefaultStartsWithName = errors.New("argument default cannot start with the argument name")
 )
 
 // RepositorySource represents valid repository sources

internal/validators/constants.go

@@ -71,6 +71,66 @@ func validatePackageField(obj *model.Package) error {
 		return ErrPackageNameHasSpaces
 	}
 
+	// Validate runtime arguments
+	for _, arg := range obj.RuntimeArguments {
+		if err := validateArgument(&arg); err != nil {
+			return fmt.Errorf("invalid runtime argument: %w", err)
+		}
+	}
+
+	// Validate package arguments
+	for _, arg := range obj.PackageArguments {
+		if err := validateArgument(&arg); err != nil {
+			return fmt.Errorf("invalid package argument: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// validateArgument validates argument details
+func validateArgument(obj *model.Argument) error {
+	if obj.Type == model.ArgumentTypeNamed {
+		// Validate named argument name format
+		if err := validateNamedArgumentName(obj.Name); err != nil {
+			return err
+		}
+
+		// Validate value and default don't start with the name
+		if err := validateArgumentValueFields(obj.Name, obj.Value, obj.Default); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func validateNamedArgumentName(name string) error {
+	// Check if name is required for named arguments
+	if name == "" {
+		return ErrNamedArgumentNameRequired
+	}
+
+	// Check for invalid characters that suggest embedded values or descriptions
+	// Valid: "--directory", "--port", "-v", "config", "verbose"
+	// Invalid: "--directory <absolute_path_to_adfin_mcp_folder>", "--port 8080"
+	if strings.Contains(name, "<") || strings.Contains(name, ">") ||
+		strings.Contains(name, " ") || strings.Contains(name, "$") {
+		return fmt.Errorf("%w: %s", ErrInvalidNamedArgumentName, name)
+	}
+
+	return nil
+}
+
+func validateArgumentValueFields(name, value, defaultValue string) error {
+	// Check if value starts with the argument name (using startsWith, not contains)
+	if value != "" && strings.HasPrefix(value, name) {
+		return fmt.Errorf("%w: value starts with argument name '%s': %s", ErrArgumentValueStartsWithName, name, value)
+	}
+
+	if defaultValue != "" && strings.HasPrefix(defaultValue, name) {
+		return fmt.Errorf("%w: default starts with argument name '%s': %s", ErrArgumentDefaultStartsWithName, name, defaultValue)
+	}
+
 	return nil
 }