docker
diff --git a/‎CLAUDE.md‎
Lines changed: 145 additions & 0 deletions b/‎CLAUDE.md‎
Lines changed: 145 additions & 0 deletions
diff --git a/‎cmd/docker-mcp/commands/gateway.go‎
Lines changed: 19 additions & 2 deletions b/‎cmd/docker-mcp/commands/gateway.go‎
Lines changed: 19 additions & 2 deletions
diff --git a/‎docs/generator/reference/docker_mcp_gateway_run.yaml‎
Lines changed: 3 additions & 2 deletions b/‎docs/generator/reference/docker_mcp_gateway_run.yaml‎
Lines changed: 3 additions & 2 deletions
diff --git a/‎docs/generator/reference/mcp_gateway_run.md‎
Lines changed: 1 addition & 0 deletions b/‎docs/generator/reference/mcp_gateway_run.md‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎pkg/catalog/types.go‎
Lines changed: 1 addition & 0 deletions b/‎pkg/catalog/types.go‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎pkg/gateway/auth.go‎
Lines changed: 97 additions & 0 deletions b/‎pkg/gateway/auth.go‎
Lines changed: 97 additions & 0 deletions
@@ -0,0 +1,145 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Overview
+
+This is the **Docker MCP Gateway** - a CLI plugin that enables easy and secure running of Model Context Protocol (MCP) servers through Docker containers. The plugin acts as a gateway between AI clients and containerized MCP servers, providing isolation, security, and management capabilities.
+
+## Architecture
+
+The codebase follows a gateway pattern where:
+- **AI Client** connects to the **MCP Gateway** 
+- **MCP Gateway** (this CLI) manages multiple **MCP Servers** running in Docker containers
+
+Key architectural components:
+- **Gateway**: Core routing and protocol translation (`cmd/docker-mcp/internal/gateway/`)
+- **Client Management**: Handles connections to AI clients (`cmd/docker-mcp/client/`)
+- **Server Management**: Manages MCP server lifecycle (`cmd/docker-mcp/server/`)
+- **Catalog System**: Manages available MCP servers (`cmd/docker-mcp/catalog/`)
+- **Security**: Secrets management and OAuth flows (`cmd/docker-mcp/secret-management/`, `cmd/docker-mcp/oauth/`)
+
+## Development Commands
+
+### Building
+```bash
+# Build the CLI plugin locally
+make docker-mcp
+
+# Cross-compile for all platforms
+make docker-mcp-cross
+```
+
+### Testing
+```bash
+# Run all tests
+make test
+
+# Run integration tests specifically
+make integration
+
+# Run long-lived integration tests
+go test -count=1 ./... -run 'TestLongLived'
+
+# Run specific tests by pattern
+go test -count=1 ./... -run 'TestIntegration'
+
+# Run a single test file
+go test ./cmd/docker-mcp/server/server_test.go
+
+# Run tests with coverage
+go test -cover ./...
+```
+
+### Code Quality
+```bash
+# Format code
+make format
+
+# Run linter
+make lint
+
+# Run linter for specific platform
+make lint-linux
+make lint-darwin
+
+# Run Go vet (static analysis)
+go vet ./...
+
+# Run Go mod tidy to clean dependencies
+go mod tidy
+```
+
+## Project Structure
+
+- `cmd/docker-mcp/` - Main CLI application entry point
+- `cmd/docker-mcp/internal/gateway/` - Core gateway implementation with client pooling, proxy management, and transport handling
+- `cmd/docker-mcp/internal/docker/` - Docker integration for container management
+- `cmd/docker-mcp/internal/mcp/` - MCP protocol implementations (stdio, SSE)
+- `cmd/docker-mcp/internal/desktop/` - Docker Desktop integration and authentication
+- `cmd/docker-mcp/catalog/` - Server catalog management commands
+- `cmd/docker-mcp/client/` - Client configuration and connection management
+- `cmd/docker-mcp/server/` - Server lifecycle management commands  
+- `cmd/docker-mcp/tools/` - Tool execution and management
+- `examples/` - Usage examples and compose configurations
+- `docs/` - Technical documentation
+
+## Key Configuration Files
+
+The CLI uses these configuration files (typically in `~/.docker/mcp/`):
+- `docker-mcp.yaml` - Server catalog definitions
+- `registry.yaml` - Registry of enabled servers  
+- `config.yaml` - Gateway configuration and options
+
+## Important Patterns
+
+### Transport Modes
+The gateway supports multiple transport modes:
+- `stdio` - Standard input/output (default)
+- `streaming` - HTTP streaming for multiple clients
+- `sse` - Server-sent events
+
+### Security Features
+- Container isolation for MCP servers
+- Secrets management via Docker Desktop
+- OAuth flow handling
+- API key and credential protection
+- Call interception and logging
+
+### Client Integration
+The system integrates with various AI clients:
+- VS Code / Cursor
+- Claude Desktop  
+- Continue Dev
+- Custom MCP clients
+
+Configuration files for different clients are automatically managed in `cmd/docker-mcp/client/testdata/`.
+
+## CLI Plugin Development
+
+This is a Docker CLI plugin written in Go 1.24+. Key development patterns:
+
+### Plugin Installation
+The plugin is installed as `docker-mcp` and becomes available as `docker mcp <command>`. The Makefile handles building and installing to the correct Docker CLI plugins directory (`~/.docker/cli-plugins/`).
+
+### Command Structure
+Commands follow the Cobra CLI pattern with the main command tree defined in `cmd/docker-mcp/commands/`. Each major command area (catalog, server, client, etc.) has its own file.
+
+### Configuration Management
+The CLI uses YAML configuration files stored in `~/.docker/mcp/`:
+- Server definitions are loaded from catalog files
+- Runtime configuration is managed through config.yaml
+- Server enablement tracked in registry.yaml
+
+### Container Lifecycle
+MCP servers run as Docker containers with proper lifecycle management:
+- Images are pulled and validated before use  
+- Containers have consistent naming patterns
+- Health checks and logging are built-in
+- Proper cleanup on shutdown
+
+### Testing Patterns
+- Integration tests require Docker daemon
+- Long-lived tests run actual container scenarios
+- Mock configurations in testdata directories
+- Use `go test -count=1` to disable test caching
@@ -77,6 +77,9 @@ func gatewayCommand(docker docker.Client, dockerCli command.Cli) *cobra.Command
 			// Check if dynamic tools feature is enabled
 			options.DynamicTools = isDynamicToolsFeatureEnabled(dockerCli)
 
+			// Check if tool name prefix feature is enabled
+			options.ToolNamePrefix = isToolNamePrefixFeatureEnabled(dockerCli)
+
 			// Update catalog URL based on mcp-oauth-dcr flag if using default Docker catalog URL
 			if len(options.CatalogPath) == 1 && (options.CatalogPath[0] == catalog.DockerCatalogURLV2 || options.CatalogPath[0] == catalog.DockerCatalogURLV3) {
 				options.CatalogPath[0] = catalog.GetDockerCatalogURL(options.McpOAuthDcrEnabled)
@@ -160,7 +163,7 @@ func gatewayCommand(docker docker.Client, dockerCli command.Cli) *cobra.Command
 	runCmd.Flags().StringArrayVar(&options.OciRef, "oci-ref", options.OciRef, "OCI image references to use")
 	runCmd.Flags().StringSliceVar(&mcpRegistryUrls, "mcp-registry", nil, "MCP registry URLs to fetch servers from (can be repeated)")
 	runCmd.Flags().IntVar(&options.Port, "port", options.Port, "TCP port to listen on (default is to listen on stdio)")
-	runCmd.Flags().StringVar(&options.Transport, "transport", options.Transport, "stdio, sse or streaming (default is stdio)")
+	runCmd.Flags().StringVar(&options.Transport, "transport", options.Transport, "stdio, sse or streaming. Uses MCP_GATEWAY_AUTH_TOKEN environment variable for localhost authentication to prevent dns rebinding attacks.")
 	runCmd.Flags().BoolVar(&options.LogCalls, "log-calls", options.LogCalls, "Log calls to the tools")
 	runCmd.Flags().BoolVar(&options.BlockSecrets, "block-secrets", options.BlockSecrets, "Block secrets from being/received sent to/from tools")
 	runCmd.Flags().BoolVar(&options.BlockNetwork, "block-network", options.BlockNetwork, "Block tools from accessing forbidden network resources")
@@ -176,7 +179,6 @@ func gatewayCommand(docker docker.Client, dockerCli command.Cli) *cobra.Command
 	runCmd.Flags().StringVar(&options.LogFilePath, "log", options.LogFilePath, "Path to log file for stderr output (relative or absolute)")
 
 	// Very experimental features
-	_ = runCmd.Flags().MarkHidden("transport")
 	_ = runCmd.Flags().MarkHidden("log")
 
 	cmd.AddCommand(runCmd)
@@ -303,3 +305,18 @@ func isDynamicToolsFeatureEnabled(dockerCli command.Cli) bool {
 
 	return value == "enabled"
 }
+
+// isToolNamePrefixFeatureEnabled checks if the tool-name-prefix feature is enabled
+func isToolNamePrefixFeatureEnabled(dockerCli command.Cli) bool {
+	configFile := dockerCli.ConfigFile()
+	if configFile == nil || configFile.Features == nil {
+		return false
+	}
+
+	value, exists := configFile.Features["tool-name-prefix"]
+	if !exists {
+		return false
+	}
+
+	return value == "enabled"
+}
@@ -275,9 +275,10 @@ options:
     - option: transport
       value_type: string
       default_value: stdio
-      description: stdio, sse or streaming (default is stdio)
+      description: |
+        stdio, sse or streaming. Uses MCP_GATEWAY_AUTH_TOKEN environment variable for localhost authentication to prevent dns rebinding attacks.
       deprecated: false
-      hidden: true
+      hidden: false
       experimental: false
       experimentalcli: false
       kubernetes: false
 
@@ -32,6 +32,7 @@ Run the gateway
 | `--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/)                                                                             |
+| `--transport`               | `string`      | `stdio`             | stdio, sse or streaming. Uses MCP_GATEWAY_AUTH_TOKEN environment variable for localhost authentication to prevent dns rebinding attacks.      |
 | `--verbose`                 | `bool`        |                     | Verbose output                                                                                                                                |
 | `--verify-signatures`       | `bool`        |                     | Verify signatures of the server images                                                                                                        |
 | `--watch`                   | `bool`        | `true`              | Watch for changes and reconfigure the gateway                                                                                                 |
 
@@ -31,6 +31,7 @@ type Server struct {
 	AllowHosts     []string `yaml:"allowHosts,omitempty" json:"allowHosts,omitempty"`
 	Tools          []Tool   `yaml:"tools,omitempty" json:"tools,omitempty"`
 	Config         []any    `yaml:"config,omitempty" json:"config,omitempty"`
+	Prefix         string   `yaml:"prefix,omitempty" json:"prefix,omitempty"`
 }
 
 type Secret struct {
 
@@ -0,0 +1,97 @@
+package gateway
+
+import (
+	"crypto/rand"
+	"crypto/subtle"
+	"fmt"
+	"math/big"
+	"net/http"
+	"os"
+)
+
+const (
+	tokenLength = 50
+	// Characters to use for random token generation (lowercase letters and numbers)
+	tokenCharset = "abcdefghijklmnopqrstuvwxyz0123456789"
+)
+
+// generateAuthToken generates a random 50-character string using lowercase letters and numbers
+func generateAuthToken() (string, error) {
+	token := make([]byte, tokenLength)
+	charsetLen := big.NewInt(int64(len(tokenCharset)))
+
+	for i := range tokenLength {
+		num, err := rand.Int(rand.Reader, charsetLen)
+		if err != nil {
+			return "", fmt.Errorf("failed to generate random token: %w", err)
+		}
+		token[i] = tokenCharset[num.Int64()]
+	}
+
+	return string(token), nil
+}
+
+// getOrGenerateAuthToken retrieves the auth token from environment variable MCP_GATEWAY_AUTH_TOKEN
+// or generates a new one if not set or empty
+func getOrGenerateAuthToken() (string, bool, error) {
+	envToken := os.Getenv("MCP_GATEWAY_AUTH_TOKEN")
+	if envToken != "" {
+		return envToken, false, nil // false indicates token was from environment
+	}
+
+	token, err := generateAuthToken()
+	if err != nil {
+		return "", false, err
+	}
+	return token, true, nil // true indicates token was generated
+}
+
+// authenticationMiddleware creates an HTTP middleware that validates requests using
+// Bearer token in the Authorization header.
+//
+// The /health endpoint is excluded from authentication.
+func authenticationMiddleware(authToken string, next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Skip authentication for health check endpoint
+		if r.URL.Path == "/health" {
+			next.ServeHTTP(w, r)
+			return
+		}
+
+		authenticated := false
+
+		// Check for Bearer token in Authorization header
+		authHeader := r.Header.Get("Authorization")
+		if authHeader != "" {
+			// Extract Bearer token from "Bearer <token>" format
+			const bearerPrefix = "Bearer "
+			if len(authHeader) > len(bearerPrefix) && authHeader[:len(bearerPrefix)] == bearerPrefix {
+				bearerToken := authHeader[len(bearerPrefix):]
+				// Use constant-time comparison to prevent timing attacks
+				if subtle.ConstantTimeCompare([]byte(bearerToken), []byte(authToken)) == 1 {
+					authenticated = true
+				}
+			}
+		}
+
+		if !authenticated {
+			// Return 401 Unauthorized with WWW-Authenticate header
+			w.Header().Set("WWW-Authenticate", `Bearer realm="MCP Gateway"`)
+			http.Error(w, "Unauthorized", http.StatusUnauthorized)
+			return
+		}
+
+		// Authentication successful, proceed to next handler
+		next.ServeHTTP(w, r)
+	})
+}
+
+// formatGatewayURL formats the gateway URL without authentication info
+func formatGatewayURL(port int, endpoint string) string {
+	return fmt.Sprintf("http://localhost:%d%s", port, endpoint)
+}
+
+// formatBearerToken formats the Bearer token for display in the Authorization header
+func formatBearerToken(authToken string) string {
+	return fmt.Sprintf("Authorization: Bearer %s", authToken)
+}
Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,7 @@ type Server struct {`
`31`	`31`	AllowHosts []string `yaml:"allowHosts,omitempty" json:"allowHosts,omitempty"`
`32`	`32`	Tools []Tool `yaml:"tools,omitempty" json:"tools,omitempty"`
`33`	`33`	Config []any `yaml:"config,omitempty" json:"config,omitempty"`
	`34`	+ Prefix string `yaml:"prefix,omitempty" json:"prefix,omitempty"`
`34`	`35`	`}`
`35`	`36`
`36`	`37`	`type Secret struct {`