Move the schema update script to a unit test

Signed-off-by: Radoslav Dimitrov <[email protected]>

Author: rdimitrov

Taskfile.yml

@@ -260,13 +260,6 @@ tasks:
     cmds:
       - ./{{.BUILD_DIR}}/registry-builder version
 
-  sync-schema:
-    desc: Sync schema reference with Go dependency version
-    cmds:
-      - echo "🔄 Syncing schema version with Go dependency..."
-      - ./scripts/sync-schema-version.sh
-      - echo "✅ Schema sync complete. Run 'task validate' to verify."
-
   watch:
     desc: Watch for changes and rebuild (requires entr)
     cmds:

pkg/registry/official.go

@@ -71,17 +71,53 @@ func (or *OfficialRegistry) ValidateAgainstSchema() error {
 }
 
 // validateRegistry validates a registry object against the schema
-// This validates each server entry against the upstream MCP server schema,
-// ensuring compatibility with the official MCP registry format
-func (*OfficialRegistry) validateRegistry(registry *ToolHiveRegistryType) error {
+// This validates both the wrapper structure and each server entry
+func (or *OfficialRegistry) validateRegistry(registry *ToolHiveRegistryType) error {
+	var allErrors []string
+
+	// Step 1: Validate the wrapper structure against the ToolHive registry schema
+	registryJSON, err := json.Marshal(registry)
+	if err != nil {
+		return fmt.Errorf("failed to marshal registry: %w", err)
+	}
+
+	// Load the wrapper schema from local file
+	wrapperSchemaPath := "schemas/registry.schema.json"
+	wrapperSchemaLoader := gojsonschema.NewReferenceLoader("file://" + wrapperSchemaPath)
+
+	wrapperLoader := gojsonschema.NewBytesLoader(registryJSON)
+	wrapperResult, err := gojsonschema.Validate(wrapperSchemaLoader, wrapperLoader)
+	if err != nil {
+		return fmt.Errorf("wrapper schema validation failed: %w", err)
+	}
+
+	if !wrapperResult.Valid() {
+		for _, desc := range wrapperResult.Errors() {
+			allErrors = append(allErrors, fmt.Sprintf("wrapper: %s", desc.String()))
+		}
+	}
+
+	// Step 2: Validate each server individually against the upstream MCP server schema
+	if err := or.validateServers(registry.Data.Servers, &allErrors); err != nil {
+		return err
+	}
+
+	if len(allErrors) > 0 {
+		return fmt.Errorf("validation errors: %v", allErrors)
+	}
+
+	return nil
+}
+
+// validateServers validates each server entry against the upstream MCP server schema
+// This function can be used standalone to validate individual servers
+func (*OfficialRegistry) validateServers(servers []upstream.ServerJSON, allErrors *[]string) error {
 	// Use the upstream schema URL directly from the registry package
 	// This ensures we're always validating against the same schema version
 	// that the code is built with, eliminating the need for manual schema syncing
-	schemaLoader := gojsonschema.NewReferenceLoader(model.CurrentSchemaURL)
+	serverSchemaLoader := gojsonschema.NewReferenceLoader(model.CurrentSchemaURL)
 
-	// Validate each server individually against the upstream schema
-	var allErrors []string
-	for i, server := range registry.Data.Servers {
+	for i, server := range servers {
 		// Marshal server to JSON
 		serverJSON, err := json.Marshal(server)
 		if err != nil {
@@ -92,22 +128,18 @@ func (*OfficialRegistry) validateRegistry(registry *ToolHiveRegistryType) error
 		documentLoader := gojsonschema.NewBytesLoader(serverJSON)
 
 		// Perform validation
-		result, err := gojsonschema.Validate(schemaLoader, documentLoader)
+		result, err := gojsonschema.Validate(serverSchemaLoader, documentLoader)
 		if err != nil {
 			return fmt.Errorf("schema validation failed for server %d (%s): %w", i, server.Name, err)
 		}
 
 		if !result.Valid() {
 			for _, desc := range result.Errors() {
-				allErrors = append(allErrors, fmt.Sprintf("data.servers.%d: %s", i, desc.String()))
+				*allErrors = append(*allErrors, fmt.Sprintf("data.servers.%d: %s", i, desc.String()))
 			}
 		}
 	}
 
-	if len(allErrors) > 0 {
-		return fmt.Errorf("validation errors: %v", allErrors)
-	}
-
 	return nil
 }
 
@@ -304,6 +336,7 @@ func (*OfficialRegistry) createRemotes(entry *types.RegistryEntry) []model.Trans
 
 
 // createXPublisherExtensions creates x-publisher extensions with ToolHive-specific data
+// Following the reverse DNS naming convention: io.github.stacklok
 func (or *OfficialRegistry) createXPublisherExtensions(entry *types.RegistryEntry) map[string]interface{} {
 	// Get the key for the ToolHive extensions (image or URL)
 	var key string
@@ -318,8 +351,9 @@ func (or *OfficialRegistry) createXPublisherExtensions(entry *types.RegistryEntr
 	// Create ToolHive-specific extensions
 	toolhiveExtensions := or.createToolHiveExtensions(entry)
 
+	// Use reverse DNS naming convention for vendor-specific data
 	return map[string]interface{}{
-		"toolhive": map[string]interface{}{
+		"io.github.stacklok": map[string]interface{}{
 			key: toolhiveExtensions,
 		},
 	}
@@ -332,6 +366,9 @@ func (or *OfficialRegistry) createToolHiveExtensions(entry *types.RegistryEntry)
 	// Always include transport type
 	extensions["transport"] = entry.GetTransport()
 
+	// Add status (active/deprecated)
+	extensions["status"] = string(or.convertStatus(entry.GetStatus()))
+
 	// Add tools list
 	if tools := entry.GetTools(); len(tools) > 0 {
 		extensions["tools"] = tools
@@ -499,6 +536,6 @@ func (*OfficialRegistry) convertNameToReverseDNS(name string) string {
 		return name
 	}
 
-	// Convert simple names to toolhive namespace format
-	return "io.stacklok.toolhive/" + name
+	// Convert simple names to GitHub-based namespace format
+	return "io.github.stacklok/" + name
 }

pkg/registry/schema_version_test.go

@@ -0,0 +1,80 @@
+package registry
+
+import (
+	"encoding/json"
+	"os"
+	"regexp"
+	"testing"
+
+	"github.com/modelcontextprotocol/registry/pkg/model"
+)
+
+// TestSchemaVersionSync ensures that the schema reference in registry.schema.json
+// matches the schema version from the Go package (model.CurrentSchemaVersion).
+// This prevents schema drift when upgrading the registry package.
+func TestSchemaVersionSync(t *testing.T) {
+	// Read the schema file
+	schemaPath := "../../schemas/registry.schema.json"
+	schemaData, err := os.ReadFile(schemaPath)
+	if err != nil {
+		t.Fatalf("Failed to read schema file: %v", err)
+	}
+
+	// Parse the schema JSON
+	var schema map[string]interface{}
+	if err := json.Unmarshal(schemaData, &schema); err != nil {
+		t.Fatalf("Failed to parse schema JSON: %v", err)
+	}
+
+	// Navigate to the $ref field
+	servers, ok := schema["properties"].(map[string]interface{})["data"].(map[string]interface{})["properties"].(map[string]interface{})["servers"].(map[string]interface{})
+	if !ok {
+		t.Fatal("Failed to navigate to servers field in schema")
+	}
+
+	items, ok := servers["items"].(map[string]interface{})
+	if !ok {
+		t.Fatal("Failed to get items field from servers")
+	}
+
+	refURL, ok := items["$ref"].(string)
+	if !ok {
+		t.Fatal("Failed to get $ref URL from items")
+	}
+
+	// Extract the date from the URL
+	// Expected format: https://static.modelcontextprotocol.io/schemas/2025-10-17/server.schema.json
+	re := regexp.MustCompile(`/schemas/([0-9]{4}-[0-9]{2}-[0-9]{2})/`)
+	matches := re.FindStringSubmatch(refURL)
+	if len(matches) != 2 {
+		t.Fatalf("Failed to extract date from schema URL: %s", refURL)
+	}
+	schemaDate := matches[1]
+
+	// Compare with the Go package constant
+	expectedDate := model.CurrentSchemaVersion
+	if schemaDate != expectedDate {
+		t.Errorf("Schema version mismatch!\n"+
+			"  Schema file (%s): %s\n"+
+			"  Go package (model.CurrentSchemaVersion): %s\n\n"+
+			"To fix: Update schemas/registry.schema.json line 49 to use date %s:\n"+
+			"  \"$ref\": \"https://static.modelcontextprotocol.io/schemas/%s/server.schema.json\"",
+			schemaPath, schemaDate, expectedDate, expectedDate, expectedDate)
+	}
+
+	// Also check the _schema_version metadata for documentation
+	schemaVersionMeta, ok := schema["_schema_version"].(map[string]interface{})
+	if !ok {
+		t.Log("Warning: _schema_version metadata not found (non-critical)")
+		return
+	}
+
+	metaDate, ok := schemaVersionMeta["schema_date"].(string)
+	if ok && metaDate != expectedDate {
+		t.Errorf("Schema version metadata is out of sync!\n"+
+			"  _schema_version.schema_date: %s\n"+
+			"  Expected: %s\n\n"+
+			"Update the _schema_version.schema_date field in schemas/registry.schema.json",
+			metaDate, expectedDate)
+	}
+}

renovate.json

@@ -34,21 +34,10 @@
       "automerge": true
     },
     {
-      "description": "MCP Registry dependency updates with automated schema sync",
+      "description": "MCP Registry dependency updates",
       "matchPackageNames": [
         "github.com/modelcontextprotocol/registry"
       ],
-      "postUpgradeTasks": {
-        "commands": [
-          "chmod +x scripts/sync-schema-version.sh",
-          "./scripts/sync-schema-version.sh"
-        ],
-        "fileFilters": [
-          "schemas/registry.schema.json"
-        ],
-        "executionMode": "update"
-      },
-      "prBodyTemplate": "## 🔄 MCP Registry Dependency Update\n\nThis PR updates the MCP registry dependency and automatically syncs the schema reference.\n\n### Changes\n- **Dependency**: `github.com/modelcontextprotocol/registry` `{{currentVersion}}` → `{{newVersion}}`\n- **Schema**: Automatically synced schema reference commit SHA to match the updated dependency\n\n### ✅ Automated Tasks Completed\n- ✅ **Go Modules**: Updated and tidied\n- ✅ **Schema Sync**: Schema reference updated to match dependency version\n\n### 🚀 Next Steps\nThis PR will be validated by the CI workflow:\n- **Registry Validation**: All registry entries will be validated against the new schema\n- **Registry Build**: Both ToolHive and Official MCP formats will be built and tested\n- **Tool Updates**: Any affected registry spec files will be automatically updated\n\nIf validation passes, this PR can be merged immediately. If validation fails, the PR will be converted to draft status with detailed error information.\n\n---\n\n🤖 This PR was created automatically by Renovate with enhanced MCP registry support.\n\n{{{links}}}\n\n{{{controls}}}",
       "commitMessageTopic": "MCP registry dependency",
       "semanticCommitType": "chore",
       "semanticCommitScope": "deps"

schemas/registry.schema.json

@@ -46,7 +46,7 @@
           "type": "array",
           "description": "Array of MCP servers using the official MCP server schema",
           "items": {
-            "$ref": "https://raw.githubusercontent.com/modelcontextprotocol/registry/f975e68cf25c776160d4e837919884ca026027d6/docs/reference/server-json/server.schema.json#/$defs/ServerDetail"
+            "$ref": "https://static.modelcontextprotocol.io/schemas/2025-10-17/server.schema.json"
           }
         },
         "groups": {
@@ -61,9 +61,9 @@
     }
   },
   "_schema_version": {
-    "mcp_registry_version": "v1.0.0",
-    "mcp_registry_commit": "f975e68cf25c776160d4e837919884ca026027d6",
-    "updated_at": "2025-09-11T14:07:36Z",
-    "updated_by": "sync-schema-version.sh"
+    "mcp_registry_version": "v1.3.3",
+    "schema_date": "2025-10-17",
+    "updated_at": "2025-10-22T12:35:00Z",
+    "updated_by": "manual update to use static.modelcontextprotocol.io schema URL"
   }
 }