Merge pull request #69 from docker/slim/multi-catalogs

Support additional catalogs

Author: dgageot

cmd/docker-mcp/commands/gateway.go

@@ -19,10 +19,13 @@ func gatewayCommand(docker docker.Client) *cobra.Command {
 
 	// Have different defaults for the on-host gateway and the in-container gateway.
 	var options gateway.Config
+	var additionalCatalogs []string
+	var additionalRegistries []string
+	var additionalConfigs []string
 	if os.Getenv("DOCKER_MCP_IN_CONTAINER") == "1" {
 		// In-container.
 		options = gateway.Config{
-			CatalogPath: catalog.DockerCatalogURL,
+			CatalogPath: []string{catalog.DockerCatalogURL},
 			SecretsPath: "docker-desktop:/run/secrets/mcp_secret:/.env",
 			Options: gateway.Options{
 				Cpus:             1,
@@ -37,9 +40,9 @@ func gatewayCommand(docker docker.Client) *cobra.Command {
 	} else {
 		// On-host.
 		options = gateway.Config{
-			CatalogPath:  "docker-mcp.yaml",
-			RegistryPath: "registry.yaml",
-			ConfigPath:   "config.yaml",
+			CatalogPath:  []string{"docker-mcp.yaml"},
+			RegistryPath: []string{"registry.yaml"},
+			ConfigPath:   []string{"config.yaml"},
 			SecretsPath:  "docker-desktop",
 			Options: gateway.Options{
 				Cpus:         1,
@@ -65,14 +68,21 @@ func gatewayCommand(docker docker.Client) *cobra.Command {
 				options.Port = 8811
 			}
 
+			// Append additional catalogs to the main catalog path
+			options.CatalogPath = append(options.CatalogPath, additionalCatalogs...)
+			options.RegistryPath = append(options.RegistryPath, additionalRegistries...)
+			options.ConfigPath = append(options.ConfigPath, additionalConfigs...)
 			return gateway.NewGateway(options, docker).Run(cmd.Context())
 		},
 	}
 
 	runCmd.Flags().StringSliceVar(&options.ServerNames, "servers", nil, "names of the servers to enable (if non empty, ignore --registry flag)")
-	runCmd.Flags().StringVar(&options.CatalogPath, "catalog", options.CatalogPath, "path to the docker-mcp.yaml catalog (absolute or relative to ~/.docker/mcp/catalogs/)")
-	runCmd.Flags().StringVar(&options.RegistryPath, "registry", options.RegistryPath, "path to the registry.yaml (absolute or relative to ~/.docker/mcp/)")
-	runCmd.Flags().StringVar(&options.ConfigPath, "config", options.ConfigPath, "path to the config.yaml (absolute or relative to ~/.docker/mcp/)")
+	runCmd.Flags().StringSliceVar(&options.CatalogPath, "catalog", options.CatalogPath, "paths to docker catalogs (absolute or relative to ~/.docker/mcp/catalogs/)")
+	runCmd.Flags().StringSliceVar(&additionalCatalogs, "additional-catalog", nil, "additional catalog paths to append to the default catalogs")
+	runCmd.Flags().StringSliceVar(&options.RegistryPath, "registry", options.RegistryPath, "paths to the registry files (absolute or relative to ~/.docker/mcp/)")
+	runCmd.Flags().StringSliceVar(&additionalRegistries, "additional-registry", nil, "additional registry paths to merge with the default registry.yaml")
+	runCmd.Flags().StringSliceVar(&options.ConfigPath, "config", options.ConfigPath, "paths to the config files (absolute or relative to ~/.docker/mcp/)")
+	runCmd.Flags().StringSliceVar(&additionalConfigs, "additional-config", nil, "additional config paths to merge with the default config.yaml")
 	runCmd.Flags().StringVar(&options.SecretsPath, "secrets", options.SecretsPath, "colon separated paths to search for secrets. Can be `docker-desktop` or a path to a .env file (default to using Docker Deskop's secrets API)")
 	runCmd.Flags().StringSliceVar(&options.ToolNames, "tools", options.ToolNames, "List of tools to enable")
 	runCmd.Flags().StringArrayVar(&options.Interceptors, "interceptor", options.Interceptors, "List of interceptors to use (format: when:type:path, e.g. 'before:exec:/bin/path')")

cmd/docker-mcp/internal/catalog/catalog.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"log"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -15,20 +16,29 @@ import (
 )
 
 func Get(ctx context.Context) (Catalog, error) {
-	return ReadFrom(ctx, "docker-mcp.yaml")
+	return ReadFrom(ctx, []string{"docker-mcp.yaml"})
 }
 
-func ReadFrom(ctx context.Context, fileOrURL string) (Catalog, error) {
-	servers, err := readMCPServers(ctx, fileOrURL)
-	if err != nil {
-		return Catalog{}, err
-	}
-	if servers == nil {
-		servers = map[string]Server{}
+func ReadFrom(ctx context.Context, fileOrURLs []string) (Catalog, error) {
+	mergedServers := map[string]Server{}
+
+	for _, fileOrURL := range fileOrURLs {
+		servers, err := readMCPServers(ctx, fileOrURL)
+		if err != nil {
+			return Catalog{}, err
+		}
+
+		// Merge servers into the combined map, checking for overlaps
+		for key, server := range servers {
+			if _, exists := mergedServers[key]; exists {
+				log.Printf("Warning: overlapping key '%s' found in catalog '%s', overwriting previous value", key, fileOrURL)
+			}
+			mergedServers[key] = server
+		}
 	}
 
 	return Catalog{
-		Servers: servers,
+		Servers: mergedServers,
 	}, nil
 }
 

cmd/docker-mcp/internal/gateway/config.go

@@ -3,9 +3,9 @@ package gateway
 type Config struct {
 	Options
 	ServerNames  []string
-	CatalogPath  string
-	ConfigPath   string
-	RegistryPath string
+	CatalogPath  []string
+	ConfigPath   []string
+	RegistryPath []string
 	SecretsPath  string
 }
 

cmd/docker-mcp/internal/gateway/configuration.go

@@ -86,10 +86,10 @@ func (c *Configuration) Find(serverName string) (*catalog.ServerConfig, *map[str
 }
 
 type FileBasedConfiguration struct {
-	CatalogPath  string
+	CatalogPath  []string
 	ServerNames  []string // Takes precedence over the RegistryPath
-	RegistryPath string
-	ConfigPath   string
+	RegistryPath []string
+	ConfigPath   []string
 	SecretsPath  string // Optional, if not set, use Docker Desktop's secrets API
 	Watch        bool
 
@@ -105,17 +105,28 @@ func (c *FileBasedConfiguration) Read(ctx context.Context) (Configuration, chan
 		return configuration, nil, func() error { return nil }, nil
 	}
 
-	var registryPath string
+	var registryPaths []string
 	if len(c.ServerNames) == 0 {
-		registryPath, err = config.FilePath(c.RegistryPath)
-		if err != nil {
-			return Configuration{}, nil, nil, err
+		for _, path := range c.RegistryPath {
+			if path != "" {
+				registryPath, err := config.FilePath(path)
+				if err != nil {
+					return Configuration{}, nil, nil, err
+				}
+				registryPaths = append(registryPaths, registryPath)
+			}
 		}
 	}
 
-	configPath, err := config.FilePath(c.ConfigPath)
-	if err != nil {
-		return Configuration{}, nil, nil, err
+	var configPaths []string
+	for _, path := range c.ConfigPath {
+		if path != "" {
+			configPath, err := config.FilePath(path)
+			if err != nil {
+				return Configuration{}, nil, nil, err
+			}
+			configPaths = append(configPaths, configPath)
+		}
 	}
 
 	watcher, err := fsnotify.NewWatcher()
@@ -142,29 +153,30 @@ func (c *FileBasedConfiguration) Read(ctx context.Context) (Configuration, chan
 					}
 				}
 
-				if configuration, err := c.readOnce(ctx); err == nil {
-					updates <- configuration
-				}
-			case err, ok := <-watcher.Errors:
-				if !ok {
-					return
+				configuration, err := c.readOnce(ctx)
+				if err != nil {
+					log("Error reading configuration:", err)
+					continue
 				}
-				logf("watch error: %s", err)
+
+				updates <- configuration
+
+			case <-ctx.Done():
+				return
 			}
 		}
 	}()
 
-	if registryPath != "" {
-		log("- Watching registry at", registryPath)
-		if err := watcher.Add(registryPath); err != nil {
-			_ = watcher.Close()
+	// Add all registry paths to watcher
+	for _, path := range registryPaths {
+		if err := watcher.Add(path); err != nil && !os.IsNotExist(err) {
 			return Configuration{}, nil, nil, err
 		}
 	}
-	if configPath != "" {
-		log("- Watching config at", configPath)
-		if err := watcher.Add(configPath); err != nil {
-			_ = watcher.Close()
+
+	// Add all config paths to watcher
+	for _, path := range configPaths {
+		if err := watcher.Add(path); err != nil && !os.IsNotExist(err) {
 			return Configuration{}, nil, nil, err
 		}
 	}
@@ -239,41 +251,75 @@ func (c *FileBasedConfiguration) readCatalog(ctx context.Context) (catalog.Catal
 }
 
 func (c *FileBasedConfiguration) readRegistry(ctx context.Context) (config.Registry, error) {
-	if c.RegistryPath == "" {
+	if len(c.RegistryPath) == 0 {
 		return config.Registry{}, nil
 	}
 
-	log("  - Reading registry from", c.RegistryPath)
-	yaml, err := config.ReadConfigFile(ctx, c.docker, c.RegistryPath)
-	if err != nil {
-		return config.Registry{}, fmt.Errorf("reading registry.yaml: %w", err)
+	mergedRegistry := config.Registry{
+		Servers: map[string]config.Tile{},
 	}
 
-	cfg, err := config.ParseRegistryConfig(yaml)
-	if err != nil {
-		return config.Registry{}, fmt.Errorf("parsing registry.yaml: %w", err)
+	for _, registryPath := range c.RegistryPath {
+		if registryPath == "" {
+			continue
+		}
+
+		log("  - Reading registry from", registryPath)
+		yaml, err := config.ReadConfigFile(ctx, c.docker, registryPath)
+		if err != nil {
+			return config.Registry{}, fmt.Errorf("reading registry file %s: %w", registryPath, err)
+		}
+
+		cfg, err := config.ParseRegistryConfig(yaml)
+		if err != nil {
+			return config.Registry{}, fmt.Errorf("parsing registry file %s: %w", registryPath, err)
+		}
+
+		// Merge servers into the combined registry, checking for overlaps
+		for serverName, tile := range cfg.Servers {
+			if _, exists := mergedRegistry.Servers[serverName]; exists {
+				log(fmt.Sprintf("Warning: overlapping server '%s' found in registry '%s', overwriting previous value", serverName, registryPath))
+			}
+			mergedRegistry.Servers[serverName] = tile
+		}
 	}
 
-	return cfg, nil
+	return mergedRegistry, nil
 }
 
 func (c *FileBasedConfiguration) readConfig(ctx context.Context) (map[string]map[string]any, error) {
-	if c.ConfigPath == "" {
+	if len(c.ConfigPath) == 0 {
 		return map[string]map[string]any{}, nil
 	}
 
-	log("  - Reading config from", c.ConfigPath)
-	yaml, err := config.ReadConfigFile(ctx, c.docker, c.ConfigPath)
-	if err != nil {
-		return nil, fmt.Errorf("reading config.yaml: %w", err)
-	}
+	mergedConfig := map[string]map[string]any{}
 
-	cfg, err := config.ParseConfig(yaml)
-	if err != nil {
-		return nil, fmt.Errorf("parsing config.yaml: %w", err)
+	for _, configPath := range c.ConfigPath {
+		if configPath == "" {
+			continue
+		}
+
+		log("  - Reading config from", configPath)
+		yaml, err := config.ReadConfigFile(ctx, c.docker, configPath)
+		if err != nil {
+			return nil, fmt.Errorf("reading config file %s: %w", configPath, err)
+		}
+
+		cfg, err := config.ParseConfig(yaml)
+		if err != nil {
+			return nil, fmt.Errorf("parsing config file %s: %w", configPath, err)
+		}
+
+		// Merge configs into the combined config, checking for overlaps
+		for serverName, serverConfig := range cfg {
+			if _, exists := mergedConfig[serverName]; exists {
+				log(fmt.Sprintf("Warning: overlapping server config '%s' found in config file '%s', overwriting previous value", serverName, configPath))
+			}
+			mergedConfig[serverName] = serverConfig
+		}
 	}
 
-	return cfg, nil
+	return mergedConfig, nil
 }
 
 func (c *FileBasedConfiguration) readDockerDesktopSecrets(ctx context.Context, servers map[string]catalog.Server, serverNames []string) (map[string]string, error) {