Merge pull request #202 from docker/slim/dynamic-tools

Slim/dynamic tools

Author: slimslenderslacks

cmd/docker-mcp/commands/feature.go

@@ -199,13 +199,19 @@ func isFeatureEnabledFromCli(dockerCli command.Cli, feature string) bool {
 
 // isFeatureEnabledFromConfig checks if a feature is enabled from a config file
 func isFeatureEnabledFromConfig(configFile *configfile.ConfigFile, feature string) bool {
+	// Features that are enabled by default
+	defaultEnabledFeatures := map[string]bool{
+		"mcp-oauth-dcr": true,
+		"dynamic-tools": true,
+	}
+
 	if configFile.Features == nil {
-		return feature == "mcp-oauth-dcr" // mcp-oauth-dcr is enabled by default
+		return defaultEnabledFeatures[feature]
 	}
 
 	value, exists := configFile.Features[feature]
 	if !exists {
-		return feature == "mcp-oauth-dcr" // mcp-oauth-dcr is enabled by default
+		return defaultEnabledFeatures[feature]
 	}
 
 	// Handle both boolean string values and "enabled"/"disabled" strings

cmd/docker-mcp/commands/feature_test.go

@@ -63,7 +63,15 @@ func TestIsFeatureEnabledDynamicTools(t *testing.T) {
 			Features: make(map[string]string),
 		}
 		enabled := isFeatureEnabledFromConfig(configFile, "dynamic-tools")
-		assert.False(t, enabled, "missing features should default to disabled")
+		assert.True(t, enabled, "dynamic-tools should default to enabled when missing")
+	})
+
+	t.Run("nil features map", func(t *testing.T) {
+		configFile := &configfile.ConfigFile{
+			Features: nil,
+		}
+		enabled := isFeatureEnabledFromConfig(configFile, "dynamic-tools")
+		assert.True(t, enabled, "dynamic-tools should default to enabled when Features is nil")
 	})
 }
 

cmd/docker-mcp/commands/gateway.go

@@ -177,6 +177,7 @@ func gatewayCommand(docker docker.Client, dockerCli command.Cli) *cobra.Command
 	runCmd.Flags().StringVar(&options.Memory, "memory", options.Memory, "Memory allocated to each MCP Server (default is 2Gb)")
 	runCmd.Flags().BoolVar(&options.Static, "static", options.Static, "Enable static mode (aka pre-started servers)")
 	runCmd.Flags().StringVar(&options.LogFilePath, "log", options.LogFilePath, "Path to log file for stderr output (relative or absolute)")
+	runCmd.Flags().StringVar(&options.SessionName, "session", "", "Session name for loading and persisting configuration from ~/.docker/mcp/{SessionName}/")
 
 	// Very experimental features
 	_ = runCmd.Flags().MarkHidden("log")
@@ -295,12 +296,12 @@ func isMcpOAuthDcrFeatureEnabled(dockerCli command.Cli) bool {
 func isDynamicToolsFeatureEnabled(dockerCli command.Cli) bool {
 	configFile := dockerCli.ConfigFile()
 	if configFile == nil || configFile.Features == nil {
-		return false
+		return true // Default enabled when no config exists
 	}
 
 	value, exists := configFile.Features["dynamic-tools"]
 	if !exists {
-		return false
+		return true // Default enabled when not in config
 	}
 
 	return value == "enabled"

cmd/docker-mcp/commands/gateway_test.go

@@ -88,31 +88,31 @@ func TestIsDynamicToolsFeatureEnabled(t *testing.T) {
 			Features: map[string]string{},
 		}
 		enabled := isDynamicToolsFeatureEnabledFromConfig(configFile)
-		assert.False(t, enabled, "should return false when dynamic-tools is not set")
+		assert.True(t, enabled, "should return true when dynamic-tools is not set")
 	})
 
 	t.Run("nil config", func(t *testing.T) {
 		enabled := isDynamicToolsFeatureEnabledFromConfig(nil)
-		assert.False(t, enabled, "should return false when config is nil")
+		assert.True(t, enabled, "should return true when config is nil")
 	})
 
 	t.Run("nil features", func(t *testing.T) {
 		configFile := &configfile.ConfigFile{
 			Features: nil,
 		}
 		enabled := isDynamicToolsFeatureEnabledFromConfig(configFile)
-		assert.False(t, enabled, "should return false when features is nil")
+		assert.True(t, enabled, "should return true when features is nil")
 	})
 }
 
 // Helper function for testing (extract logic from isDynamicToolsFeatureEnabled)
 func isDynamicToolsFeatureEnabledFromConfig(configFile *configfile.ConfigFile) bool {
 	if configFile == nil || configFile.Features == nil {
-		return false
+		return true // Default enabled when no config exists
 	}
 	value, exists := configFile.Features["dynamic-tools"]
 	if !exists {
-		return false
+		return true // Default enabled when not in config
 	}
 	return value == "enabled"
 }

docs/generator/reference/docker_mcp_gateway_run.yaml

@@ -242,6 +242,16 @@ options:
       experimentalcli: false
       kubernetes: false
       swarm: false
+    - option: session
+      value_type: string
+      description: |
+        Session name for loading and persisting configuration from ~/.docker/mcp/{SessionName}/
+      deprecated: false
+      hidden: false
+      experimental: false
+      experimentalcli: false
+      kubernetes: false
+      swarm: false
     - option: static
       value_type: bool
       default_value: "false"

docs/generator/reference/mcp_gateway_run.md

@@ -29,6 +29,7 @@ Run the gateway
 | `--registry`                | `stringSlice` | `[registry.yaml]`   | Paths to the registry files (absolute or relative to ~/.docker/mcp/)                                                                          |
 | `--secrets`                 | `string`      | `docker-desktop`    | Colon separated paths to search for secrets. Can be `docker-desktop` or a path to a .env file (default to using Docker Desktop's secrets API) |
 | `--servers`                 | `stringSlice` |                     | Names of the servers to enable (if non empty, ignore --registry flag)                                                                         |
+| `--session`                 | `string`      |                     | Session name for loading and persisting configuration from ~/.docker/mcp/{SessionName}/                                                       |
 | `--static`                  | `bool`        |                     | Enable static mode (aka pre-started servers)                                                                                                  |
 | `--tools`                   | `stringSlice` |                     | List of tools to enable                                                                                                                       |
 | `--tools-config`            | `stringSlice` | `[tools.yaml]`      | Paths to the tools files (absolute or relative to ~/.docker/mcp/)                                                                             |

pkg/config/readwrite.go

@@ -2,6 +2,7 @@ package config
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -111,6 +112,33 @@ func writeConfigFile(name string, content []byte) error {
 	return os.WriteFile(path, content, 0o644)
 }
 
+// WriteConfigFileToSession writes a config file to a session directory
+func WriteConfigFileToSession(sessionName, name string, content []byte) error {
+	sessionPath, err := SessionFilePath(sessionName, name)
+	if err != nil {
+		return err
+	}
+
+	if err := os.MkdirAll(filepath.Dir(sessionPath), 0o755); err != nil {
+		return err
+	}
+	return os.WriteFile(sessionPath, content, 0o644)
+}
+
+// SessionFilePath returns the file path within a session directory
+func SessionFilePath(sessionName, name string) (string, error) {
+	if sessionName == "" {
+		return "", fmt.Errorf("session name is required")
+	}
+
+	homeDir, err := user.HomeDir()
+	if err != nil {
+		return "", err
+	}
+
+	return filepath.Join(homeDir, ".docker", "mcp", sessionName, name), nil
+}
+
 func FilePath(name string) (string, error) {
 	if filepath.IsAbs(name) {
 		return name, nil

pkg/gateway/config.go

@@ -10,6 +10,7 @@ type Config struct {
 	RegistryPath       []string
 	ToolsPath          []string
 	SecretsPath        string
+	SessionName        string           // Session name for persisting configuration
 	MCPRegistryServers []catalog.Server // catalog.Server objects from MCP registries
 }
 

pkg/gateway/configuration.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/fsnotify/fsnotify"
+	"gopkg.in/yaml.v3"
 
 	"github.com/docker/mcp-gateway/pkg/catalog"
 	"github.com/docker/mcp-gateway/pkg/config"
@@ -29,6 +30,7 @@ type Configuration struct {
 	config      map[string]map[string]any
 	tools       config.ToolsConfig
 	secrets     map[string]string
+	SessionName string
 }
 
 func (c *Configuration) ServerNames() []string {
@@ -90,6 +92,51 @@ func (c *Configuration) Find(serverName string) (*catalog.ServerConfig, *map[str
 	return nil, &byName, true
 }
 
+// Persist writes the configuration files to the session directory if SessionName is set
+func (c *Configuration) Persist() error {
+	if c.SessionName == "" {
+		return nil // No session name set, nothing to persist
+	}
+
+	// Serialize and write registry.yaml
+	registry := config.Registry{
+		Servers: make(map[string]config.Tile),
+	}
+	for _, serverName := range c.serverNames {
+		registry.Servers[serverName] = config.Tile{
+			Ref: serverName,
+		}
+	}
+	registryBytes, err := yaml.Marshal(registry)
+	if err != nil {
+		return fmt.Errorf("failed to marshal registry: %w", err)
+	}
+	if err := config.WriteConfigFileToSession(c.SessionName, "registry.yaml", registryBytes); err != nil {
+		return fmt.Errorf("failed to write registry.yaml: %w", err)
+	}
+
+	// Serialize and write config.yaml
+	configBytes, err := yaml.Marshal(c.config)
+	if err != nil {
+		return fmt.Errorf("failed to marshal config: %w", err)
+	}
+	if err := config.WriteConfigFileToSession(c.SessionName, "config.yaml", configBytes); err != nil {
+		return fmt.Errorf("failed to write config.yaml: %w", err)
+	}
+
+	// Serialize and write tools.yaml
+	toolsBytes, err := yaml.Marshal(c.tools)
+	if err != nil {
+		return fmt.Errorf("failed to marshal tools: %w", err)
+	}
+	if err := config.WriteConfigFileToSession(c.SessionName, "tools.yaml", toolsBytes); err != nil {
+		return fmt.Errorf("failed to write tools.yaml: %w", err)
+	}
+
+	log.Log(fmt.Sprintf("  - Configuration persisted to session '%s'", c.SessionName))
+	return nil
+}
+
 type FileBasedConfiguration struct {
 	CatalogPath        []string
 	ServerNames        []string // Takes precedence over the RegistryPath
@@ -101,6 +148,7 @@ type FileBasedConfiguration struct {
 	MCPRegistryServers []catalog.Server // Servers fetched from MCP registries
 	Watch              bool
 	McpOAuthDcrEnabled bool
+	sessionName        string // Session name for persisting configuration
 
 	docker docker.Client
 }