Allow to set a local registry via file path (#1223)

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

Author: rdimitrov

pkg/auth/token_test.go

@@ -380,6 +380,7 @@ func writeTestServerCert(t *testing.T, server *httptest.Server) string {
 	cert := server.Certificate()
 	if cert == nil {
 		t.Fatal("Test server has no certificate")
+		return ""
 	}
 
 	// Create temp file

pkg/config/config.go

@@ -26,6 +26,7 @@ type Config struct {
 	Secrets                Secrets             `yaml:"secrets"`
 	Clients                Clients             `yaml:"clients"`
 	RegistryUrl            string              `yaml:"registry_url"`
+	LocalRegistryPath      string              `yaml:"local_registry_path"`
 	AllowPrivateRegistryIp bool                `yaml:"allow_private_registry_ip"`
 	CACertificatePath      string              `yaml:"ca_certificate_path,omitempty"`
 	OTEL                   OpenTelemetryConfig `yaml:"otel,omitempty"`

pkg/registry/factory.go

@@ -17,7 +17,10 @@ func NewRegistryProvider(cfg *config.Config) Provider {
 	if cfg != nil && len(cfg.RegistryUrl) > 0 {
 		return NewRemoteRegistryProvider(cfg.RegistryUrl, cfg.AllowPrivateRegistryIp)
 	}
-	return NewEmbeddedRegistryProvider()
+	if cfg != nil && len(cfg.LocalRegistryPath) > 0 {
+		return NewLocalRegistryProvider(cfg.LocalRegistryPath)
+	}
+	return NewLocalRegistryProvider()
 }
 
 // GetDefaultProvider returns the default registry provider instance

pkg/registry/provider_embedded.go renamed to pkg/registry/provider_local.go

@@ -4,26 +4,45 @@ import (
 	"embed"
 	"encoding/json"
 	"fmt"
+	"os"
 	"strings"
 )
 
 //go:embed data/registry.json
 var embeddedRegistryFS embed.FS
 
-// EmbeddedRegistryProvider provides registry data from embedded JSON files
-type EmbeddedRegistryProvider struct {
+// LocalRegistryProvider provides registry data from embedded JSON files or local files
+type LocalRegistryProvider struct {
+	filePath string
 }
 
-// NewEmbeddedRegistryProvider creates a new embedded registry provider
-func NewEmbeddedRegistryProvider() *EmbeddedRegistryProvider {
-	return &EmbeddedRegistryProvider{}
+// NewLocalRegistryProvider creates a new local registry provider
+// If filePath is provided, it will read from that file; otherwise uses embedded data
+func NewLocalRegistryProvider(filePath ...string) *LocalRegistryProvider {
+	var path string
+	if len(filePath) > 0 {
+		path = filePath[0]
+	}
+	return &LocalRegistryProvider{filePath: path}
 }
 
-// GetRegistry returns the embedded registry data
-func (*EmbeddedRegistryProvider) GetRegistry() (*Registry, error) {
-	data, err := embeddedRegistryFS.ReadFile("data/registry.json")
-	if err != nil {
-		return nil, fmt.Errorf("failed to read embedded registry data: %w", err)
+// GetRegistry returns the registry data from file path or embedded data
+func (p *LocalRegistryProvider) GetRegistry() (*Registry, error) {
+	var data []byte
+	var err error
+
+	if p.filePath != "" {
+		// Read from local file
+		data, err = os.ReadFile(p.filePath)
+		if err != nil {
+			return nil, fmt.Errorf("failed to read local registry file %s: %w", p.filePath, err)
+		}
+	} else {
+		// Read from embedded data
+		data, err = embeddedRegistryFS.ReadFile("data/registry.json")
+		if err != nil {
+			return nil, fmt.Errorf("failed to read embedded registry data: %w", err)
+		}
 	}
 
 	registry, err := parseRegistryData(data)
@@ -40,7 +59,7 @@ func (*EmbeddedRegistryProvider) GetRegistry() (*Registry, error) {
 }
 
 // GetServer returns a specific server by name
-func (p *EmbeddedRegistryProvider) GetServer(name string) (*ImageMetadata, error) {
+func (p *LocalRegistryProvider) GetServer(name string) (*ImageMetadata, error) {
 	reg, err := p.GetRegistry()
 	if err != nil {
 		return nil, err
@@ -55,7 +74,7 @@ func (p *EmbeddedRegistryProvider) GetServer(name string) (*ImageMetadata, error
 }
 
 // SearchServers searches for servers matching the query
-func (p *EmbeddedRegistryProvider) SearchServers(query string) ([]*ImageMetadata, error) {
+func (p *LocalRegistryProvider) SearchServers(query string) ([]*ImageMetadata, error) {
 	reg, err := p.GetRegistry()
 	if err != nil {
 		return nil, err
@@ -90,7 +109,7 @@ func (p *EmbeddedRegistryProvider) SearchServers(query string) ([]*ImageMetadata
 }
 
 // ListServers returns all available servers
-func (p *EmbeddedRegistryProvider) ListServers() ([]*ImageMetadata, error) {
+func (p *LocalRegistryProvider) ListServers() ([]*ImageMetadata, error) {
 	reg, err := p.GetRegistry()
 	if err != nil {
 		return nil, err

pkg/registry/provider_test.go

@@ -1,6 +1,8 @@
 package registry
 
 import (
+	"os"
+	"path/filepath"
 	"testing"
 
 	"github.com/stacklok/toolhive/pkg/config"
@@ -16,14 +18,14 @@ func TestNewRegistryProvider(t *testing.T) {
 		{
 			name:         "nil config returns embedded provider",
 			config:       nil,
-			expectedType: "*registry.EmbeddedRegistryProvider",
+			expectedType: "*registry.LocalRegistryProvider",
 		},
 		{
 			name: "empty registry URL returns embedded provider",
 			config: &config.Config{
 				RegistryUrl: "",
 			},
-			expectedType: "*registry.EmbeddedRegistryProvider",
+			expectedType: "*registry.LocalRegistryProvider",
 		},
 		{
 			name: "registry URL returns remote provider",
@@ -32,6 +34,21 @@ func TestNewRegistryProvider(t *testing.T) {
 			},
 			expectedType: "*registry.RemoteRegistryProvider",
 		},
+		{
+			name: "local registry path returns embedded provider with file path",
+			config: &config.Config{
+				LocalRegistryPath: "/path/to/registry.json",
+			},
+			expectedType: "*registry.LocalRegistryProvider",
+		},
+		{
+			name: "registry URL takes precedence over local path",
+			config: &config.Config{
+				RegistryUrl:       "https://example.com/registry.json",
+				LocalRegistryPath: "/path/to/registry.json",
+			},
+			expectedType: "*registry.RemoteRegistryProvider",
+		},
 	}
 
 	for _, tt := range tests {
@@ -48,9 +65,9 @@ func TestNewRegistryProvider(t *testing.T) {
 	}
 }
 
-func TestEmbeddedRegistryProvider(t *testing.T) {
+func TestLocalRegistryProvider(t *testing.T) {
 	t.Parallel()
-	provider := NewEmbeddedRegistryProvider()
+	provider := NewLocalRegistryProvider()
 
 	// Test GetRegistry
 	registry, err := provider.GetRegistry()
@@ -118,11 +135,77 @@ func TestRemoteRegistryProvider(t *testing.T) {
 	var _ Provider = provider
 }
 
+func TestLocalRegistryProviderWithLocalFile(t *testing.T) {
+	t.Parallel()
+
+	// Create a temporary registry file
+	tempDir := t.TempDir()
+	registryFile := filepath.Join(tempDir, "test_registry.json")
+
+	// Write test registry data
+	testRegistry := `{
+		"version": "1.0.0",
+		"last_updated": "2023-01-01T00:00:00Z",
+		"servers": {
+			"test-server": {
+				"image": "test/image:latest",
+				"description": "Test server",
+				"tier": "community",
+				"status": "active",
+				"transport": "stdio",
+				"permissions": {
+					"allow_local_resource_access": false,
+					"allow_internet_access": false
+				},
+				"tools": ["test-tool"],
+				"env_vars": [],
+				"args": []
+			}
+		}
+	}`
+
+	err := os.WriteFile(registryFile, []byte(testRegistry), 0644)
+	if err != nil {
+		t.Fatalf("Failed to write test registry file: %v", err)
+	}
+
+	// Test with local file path
+	provider := NewLocalRegistryProvider(registryFile)
+
+	// Test GetRegistry
+	registry, err := provider.GetRegistry()
+	if err != nil {
+		t.Fatalf("GetRegistry() error = %v", err)
+	}
+
+	if registry == nil {
+		t.Fatal("GetRegistry() returned nil registry")
+		return
+	}
+
+	if len(registry.Servers) != 1 {
+		t.Errorf("Expected 1 server, got %d", len(registry.Servers))
+	}
+
+	server, exists := registry.Servers["test-server"]
+	if !exists {
+		t.Error("Expected test-server to exist in registry")
+	}
+
+	if server.Name != "test-server" {
+		t.Errorf("Expected server name 'test-server', got '%s'", server.Name)
+	}
+
+	if server.Image != "test/image:latest" {
+		t.Errorf("Expected image 'test/image:latest', got '%s'", server.Image)
+	}
+}
+
 // getTypeName returns the type name of an interface value
 func getTypeName(v interface{}) string {
 	switch v.(type) {
-	case *EmbeddedRegistryProvider:
-		return "*registry.EmbeddedRegistryProvider"
+	case *LocalRegistryProvider:
+		return "*registry.LocalRegistryProvider"
 	case *RemoteRegistryProvider:
 		return "*registry.RemoteRegistryProvider"
 	default: