Merge pull request #286 from docker/slim/remove_session_parameter

remove --session name parameter

Author: slimslenderslacks

cmd/docker-mcp/commands/gateway.go

@@ -210,7 +210,6 @@ 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")

docs/generator/reference/docker_mcp_gateway_run.yaml

@@ -242,16 +242,6 @@ 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,7 +29,6 @@ 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/gateway/config.go

@@ -11,7 +11,6 @@ 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,7 +11,6 @@ import (
 	"time"
 
 	"github.com/fsnotify/fsnotify"
-	"gopkg.in/yaml.v3"
 
 	"github.com/docker/mcp-gateway/pkg/catalog"
 	"github.com/docker/mcp-gateway/pkg/config"
@@ -30,7 +29,6 @@ type Configuration struct {
 	config      map[string]map[string]any
 	tools       config.ToolsConfig
 	secrets     map[string]string
-	SessionName string
 }
 
 func (c *Configuration) ServerNames() []string {
@@ -92,51 +90,6 @@ 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
@@ -148,7 +101,6 @@ 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
 }

pkg/gateway/dynamic_mcps.go

@@ -487,11 +487,6 @@ func (g *Gateway) createMcpRemoveTool() *ToolRegistration {
 			return nil, fmt.Errorf("failed to remove server configuration: %w", err)
 		}
 
-		// Persist configuration if session name is set
-		if err := g.configuration.Persist(); err != nil {
-			log.Log("Warning: Failed to persist configuration:", err)
-		}
-
 		return &mcp.CallToolResult{
 			Content: []mcp.Content{&mcp.TextContent{
 				Text: fmt.Sprintf("Successfully removed server '%s'.", serverName),
@@ -811,11 +806,6 @@ func (g *Gateway) createMcpConfigSetTool(_ *clientConfig) *ToolRegistration {
 		// Log the configuration change
 		log.Log(fmt.Sprintf("  - Set config for server '%s': %s = %s", serverName, configKey, valueStr))
 
-		// Persist configuration if session name is set
-		if err := g.configuration.Persist(); err != nil {
-			log.Log("Warning: Failed to persist configuration:", err)
-		}
-
 		var resultMessage string
 		if oldValue != nil {
 			resultMessage = fmt.Sprintf("Successfully updated config for server '%s': %s = %s (was: %s)", serverName, configKey, valueStr, oldValueStr)
@@ -840,92 +830,6 @@ func (g *Gateway) createMcpConfigSetTool(_ *clientConfig) *ToolRegistration {
 	}
 }
 
-// createMcpSessionNameTool implements a tool for setting the session name
-//
-//nolint:unused
-func (g *Gateway) createMcpSessionNameTool() *ToolRegistration {
-	tool := &mcp.Tool{
-		Name:        "mcp-session-name",
-		Description: "Set a session name for the gateway configuration. When set, configuration changes will be persisted to ~/.docker/mcp/{SessionName}/ directory.",
-		InputSchema: &jsonschema.Schema{
-			Type: "object",
-			Properties: map[string]*jsonschema.Schema{
-				"name": {
-					Type:        "string",
-					Description: "Session name to set (alphanumeric and hyphens only)",
-				},
-			},
-			Required: []string{"name"},
-		},
-	}
-
-	handler := func(_ context.Context, req *mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-		// Parse parameters
-		var params struct {
-			Name string `json:"name"`
-		}
-
-		if req.Params.Arguments == nil {
-			return nil, fmt.Errorf("missing arguments")
-		}
-
-		paramsBytes, err := json.Marshal(req.Params.Arguments)
-		if err != nil {
-			return nil, fmt.Errorf("failed to marshal arguments: %w", err)
-		}
-
-		if err := json.Unmarshal(paramsBytes, &params); err != nil {
-			return nil, fmt.Errorf("failed to parse arguments: %w", err)
-		}
-
-		if params.Name == "" {
-			return nil, fmt.Errorf("name parameter is required")
-		}
-
-		sessionName := strings.TrimSpace(params.Name)
-
-		// Validate session name (alphanumeric and hyphens only)
-		if !isValidSessionName(sessionName) {
-			return &mcp.CallToolResult{
-				Content: []mcp.Content{&mcp.TextContent{
-					Text: fmt.Sprintf("Error: Invalid session name '%s'. Session names must contain only alphanumeric characters and hyphens.", sessionName),
-				}},
-			}, nil
-		}
-
-		// Set the session name
-		g.configuration.SessionName = sessionName
-
-		// Persist the current configuration to the session directory
-		if err := g.configuration.Persist(); err != nil {
-			return nil, fmt.Errorf("failed to persist configuration: %w", err)
-		}
-
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{
-				Text: fmt.Sprintf("Successfully set session name to '%s'. Configuration will now be persisted to ~/.docker/mcp/%s/", sessionName, sessionName),
-			}},
-		}, nil
-	}
-
-	return &ToolRegistration{
-		Tool:    tool,
-		Handler: withToolTelemetry("mcp-session-name", handler),
-	}
-}
-
-// isValidSessionName checks if a session name contains only alphanumeric characters and hyphens
-//
-//nolint:unused
-func isValidSessionName(name string) bool {
-	for _, ch := range name {
-		if (ch < 'a' || ch > 'z') && (ch < 'A' || ch > 'Z') && (ch < '0' || ch > '9') && ch != '-' && ch != '_' {
-			return false
-		}
-	}
-	return len(name) > 0
-}
-
 // createMcpExecTool implements a tool for executing tools that exist in the current session
 // but may not be returned from listTools calls
 func (g *Gateway) createMcpExecTool() *ToolRegistration {

pkg/gateway/mcpadd.go

@@ -244,11 +244,6 @@ func (g *Gateway) createMcpAddTool(clientConfig *clientConfig) *ToolRegistration
 			g.capabilitiesMu.Unlock()
 		}
 
-		// Persist configuration if session name is set
-		if err := g.configuration.Persist(); err != nil {
-			log.Log("Warning: Failed to persist configuration:", err)
-		}
-
 		// Get the list of tools that were just added from this server
 		var addedTools []*mcp.Tool
 		g.capabilitiesMu.RLock()

pkg/gateway/run.go

@@ -81,34 +81,17 @@ func NewGateway(config Config, docker docker.Client) *Gateway {
 	if config.WorkingSet != "" {
 		configurator = NewWorkingSetConfiguration(config.WorkingSet, oci.NewService(), docker)
 	} else {
-		// Prepend session-specific paths if SessionName is set
-		registryPath := config.RegistryPath
-		configPath := config.ConfigPath
-		toolsPath := config.ToolsPath
-
-		if config.SessionName != "" {
-			// Prepend session-specific paths to load session configs first
-			sessionRegistry := fmt.Sprintf("%s/registry.yaml", config.SessionName)
-			sessionConfig := fmt.Sprintf("%s/config.yaml", config.SessionName)
-			sessionTools := fmt.Sprintf("%s/tools.yaml", config.SessionName)
-
-			registryPath = append([]string{sessionRegistry}, registryPath...)
-			configPath = append([]string{sessionConfig}, configPath...)
-			toolsPath = append([]string{sessionTools}, toolsPath...)
-		}
-
 		configurator = &FileBasedConfiguration{
 			ServerNames:        config.ServerNames,
 			CatalogPath:        config.CatalogPath,
-			RegistryPath:       registryPath,
-			ConfigPath:         configPath,
+			RegistryPath:       config.RegistryPath,
+			ConfigPath:         config.ConfigPath,
 			SecretsPath:        config.SecretsPath,
-			ToolsPath:          toolsPath,
+			ToolsPath:          config.ToolsPath,
 			OciRef:             config.OciRef,
 			MCPRegistryServers: config.MCPRegistryServers,
 			Watch:              config.Watch,
 			McpOAuthDcrEnabled: config.McpOAuthDcrEnabled,
-			sessionName:        config.SessionName,
 			docker:             docker,
 		}
 	}
@@ -192,13 +175,6 @@ func (g *Gateway) Run(ctx context.Context) error {
 	}
 	defer func() { _ = stopConfigWatcher() }()
 
-	// Set the session name in the configuration for persistence if specified via --session flag
-	if fbc, ok := g.configurator.(*FileBasedConfiguration); ok {
-		if fbc.sessionName != "" {
-			g.configuration.SessionName = fbc.sessionName
-		}
-	}
-
 	// Parse interceptors
 	var parsedInterceptors []interceptors.Interceptor
 	if len(g.Interceptors) > 0 {