feat(mcp): add Model Context Protocol (MCP) server with HTTP transport and authentication

## Summary
Implement Model Context Protocol (MCP) server for Dubbo Admin to enable AI integration through standardized tool interfaces.

## Key Features
- **Modular Architecture**: Core components (server, registry, tools, transport, types)
- **Comprehensive Tool Support**: 11 tools covering cluster info, service discovery, instance management, metrics, and application details
- **Dual Transport Support**:
  - Stdio transport for local Claude Desktop integration
  - HTTP transport for remote connections with JSON-RPC 2.0
- **Security**: Optional Bearer Token authentication for HTTP endpoint

## Configuration

## Test plan
- [x] Unit tests for core components
- [x] Integration tests
- [x] Manual testing with Claude Desktop

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: YuZhangLarry

pkg/config/app/admin.go

@@ -18,82 +18,176 @@
 package app
 
 import (
-	"github.com/pkg/errors"
+	"github.com/duke-git/lancet/v2/slice"
 	"go.uber.org/multierr"
 
+	"github.com/apache/dubbo-admin/pkg/common/bizerror"
 	"github.com/apache/dubbo-admin/pkg/config"
 	"github.com/apache/dubbo-admin/pkg/config/console"
 	"github.com/apache/dubbo-admin/pkg/config/diagnostics"
 	"github.com/apache/dubbo-admin/pkg/config/discovery"
 	"github.com/apache/dubbo-admin/pkg/config/engine"
-	"github.com/apache/dubbo-admin/pkg/config/mode"
+	"github.com/apache/dubbo-admin/pkg/config/log"
+	"github.com/apache/dubbo-admin/pkg/config/observability"
 	"github.com/apache/dubbo-admin/pkg/config/store"
 )
 
 type AdminConfig struct {
 	config.BaseConfig
-	// Mode in which dubbo admin is running. Available values are: "test", "global", "zone"
-	Mode mode.Mode `json:"mode" envconfig:"DUBBO_MODE"`
+	// Log configuration
+	Log *log.Config `json:"log" yaml:"log"`
 	// Diagnostics configuration
-	Diagnostics *diagnostics.Config `json:"diagnostics,omitempty"`
+	Diagnostics *diagnostics.Config `json:"diagnostics,omitempty" yaml:"diagnostics"`
+	// Observability configuration
+	Observability *observability.Config `json:"observability" yaml:"observability"`
 	// Console configuration
-	Console *console.Config `json:"admin"`
+	Console *console.Config `json:"console" yaml:"console"`
 	// Store configuration
-	Store *store.Config `json:"store"`
+	Store *store.Config `json:"store" yaml:"store"`
 	// Discovery configuration
-	Discovery *discovery.Config `json:"discovery"`
+	Discovery []*discovery.Config `json:"discovery" yaml:"discovery"`
 	// Engine configuration
-	Engine *engine.Config `json:"engine"`
+	Engine *engine.Config `json:"engine" yaml:"engine"`
+	// MCP configuration
+	MCP *MCPConfig `json:"mcp,omitempty" yaml:"mcp"`
+}
+
+// MCPConfig MCP配置
+type MCPConfig struct {
+	// Enabled 是否启用MCP端点
+	Enabled bool `json:"enabled" yaml:"enabled"`
+	// Path MCP端点路径，默认 /api/mcp
+	Path string `json:"path,omitempty" yaml:"path"`
+	// APIKey MCP API密钥，用于认证。如果为空则不需要认证
+	APIKey string `json:"apiKey,omitempty" yaml:"apiKey"`
 }
 
 var _ = &AdminConfig{}
 
-func (c *AdminConfig) Sanitize() {
+var DefaultAdminConfig = func() AdminConfig {
+	return AdminConfig{
+		Log:           log.DefaultLogConfig(),
+		Store:         store.DefaultStoreConfig(),
+		Engine:        engine.DefaultResourceEngineConfig(),
+		Observability: observability.DefaultObservabilityConfig(),
+		Diagnostics:   diagnostics.DefaultDiagnosticsConfig(),
+		Console:       console.DefaultConsoleConfig(),
+	}
+}
+
+func (c AdminConfig) Sanitize() {
 	c.Engine.Sanitize()
-	c.Discovery.Sanitize()
+	for _, d := range c.Discovery {
+		d.Sanitize()
+	}
 	c.Store.Sanitize()
 	c.Console.Sanitize()
+	c.Observability.Sanitize()
 	c.Diagnostics.Sanitize()
+	c.Log.Sanitize()
 }
 
-func (c *AdminConfig) PostProcess() error {
+func (c AdminConfig) PreProcess() error {
+	discoveryPreProcess := func() error {
+		for _, d := range c.Discovery {
+			if err := d.PreProcess(); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+	return multierr.Combine(
+		c.Engine.PreProcess(),
+		discoveryPreProcess(),
+		c.Store.PreProcess(),
+		c.Console.PreProcess(),
+		c.Observability.PreProcess(),
+		c.Diagnostics.PreProcess(),
+		c.Log.PreProcess(),
+	)
+}
+
+func (c AdminConfig) PostProcess() error {
+	discoveryPostProcess := func() error {
+		for _, d := range c.Discovery {
+			if err := d.PostProcess(); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
 	return multierr.Combine(
 		c.Engine.PostProcess(),
-		c.Discovery.PostProcess(),
+		discoveryPostProcess(),
 		c.Store.PostProcess(),
 		c.Console.PostProcess(),
+		c.Observability.PostProcess(),
 		c.Diagnostics.PostProcess(),
+		c.Log.PostProcess(),
 	)
 }
 
-var DefaultAdminConfig = func() AdminConfig {
-	return AdminConfig{
-		Mode:        mode.Zone,
-		Store:       store.DefaultStoreConfig(),
-		Engine:      engine.DefaultResourceEngineConfig(),
-		Diagnostics: diagnostics.DefaultDiagnosticsConfig(),
-		Console:     console.DefaultConsoleConfig(),
-	}
-}
-
-func (c *AdminConfig) Validate() error {
-	if err := mode.ValidateMode(c.Mode); err != nil {
-		return errors.Wrap(err, "Mode Config validation failed")
+func (c AdminConfig) Validate() error {
+	if c.Log == nil {
+		c.Log = log.DefaultLogConfig()
+	} else if err := c.Log.Validate(); err != nil {
+		return bizerror.Wrap(err, bizerror.ConfigError, "log config validation failed")
 	}
 	if c.Store == nil {
 		c.Store = store.DefaultStoreConfig()
 	} else if err := c.Store.Validate(); err != nil {
-		return errors.Wrap(err, "Store Config validation failed")
+		return bizerror.Wrap(err, bizerror.ConfigError, "store config validation failed")
 	}
 	if c.Diagnostics == nil {
 		c.Diagnostics = diagnostics.DefaultDiagnosticsConfig()
 	} else if err := c.Diagnostics.Validate(); err != nil {
-		return errors.Wrap(err, "Diagnostics Config validation failed")
+		return bizerror.Wrap(err, bizerror.ConfigError, "diagnostics config validation failed")
 	}
 	if c.Console == nil {
 		c.Console = console.DefaultConsoleConfig()
 	} else if err := c.Console.Validate(); err != nil {
-		return errors.Wrap(err, "Admin validation failed")
+		return bizerror.Wrap(err, bizerror.ConfigError, "console config validation failed")
+	}
+	if c.Observability == nil {
+		c.Observability = observability.DefaultObservabilityConfig()
+	} else if err := c.Observability.Validate(); err != nil {
+		return bizerror.Wrap(err, bizerror.ConfigError, "observability config validation failed")
+	}
+	if c.Discovery == nil || len(c.Discovery) == 0 {
+		return bizerror.New(bizerror.ConfigError, "discover config is needed")
+	}
+	for _, d := range c.Discovery {
+		if err := d.Validate(); err != nil {
+			return bizerror.Wrap(err, bizerror.ConfigError, "discovery config validation failed")
+		}
+	}
+	discoveryIDList := slice.Map(c.Discovery, func(index int, item *discovery.Config) string {
+		return item.ID
+	})
+	if len(discoveryIDList) != len(slice.Unique(discoveryIDList)) {
+		return bizerror.New(bizerror.ConfigError, "discovery id must be unique")
+	}
+	if c.Engine == nil {
+		c.Engine = engine.DefaultResourceEngineConfig()
+	} else if err := c.Engine.Validate(); err != nil {
+		return bizerror.Wrap(err, bizerror.ConfigError, "engine config validation failed")
 	}
 	return nil
 }
+
+// FindDiscovery finds the DiscoveryConfig by id, returns nil if not found
+func (c AdminConfig) FindDiscovery(id string) *discovery.Config {
+	for _, d := range c.Discovery {
+		if d.ID == id {
+			return d
+		}
+	}
+	return nil
+}
+
+// Meshes return the mesh id list of discoveries
+func (c AdminConfig) Meshes() []string {
+	return slice.Map(c.Discovery, func(index int, item *discovery.Config) string {
+		return item.ID
+	})
+}