Make configuration toolsets and update docs

Signed-off-by: Alberto Gutierrez <aljesusg@gmail.com>

Author: aljesusg

docs/KIALI_INTEGRATION.md

@@ -11,7 +11,7 @@ Config (TOML):
 ```toml
 toolsets = ["core", "kiali"]
 
-[kiali]
+[toolset_configs.kiali]
 url = "https://kiali.example"
 # insecure = true  # optional: allow insecure TLS
 ```
@@ -25,7 +25,7 @@ kubernetes-mcp-server \
   [--kiali-insecure]
 ```
 
-When the `kiali` toolset is enabled, a Kiali URL is required. Without it, the server will refuse to start.
+When the `kiali` toolset is enabled, a Kiali toolset configuration is required. Provide it via `[toolset_configs.kiali]` in the config file or by passing flags (which populate the toolset config). If missing or invalid, the server will refuse to start.
 
 ### How authentication works
 
@@ -38,7 +38,8 @@ When the `kiali` toolset is enabled, a Kiali URL is required. Without it, the se
 
 ### Troubleshooting
 
-- Error: "kiali-url is required when kiali tools are enabled" → provide `--kiali-url` or set `[kiali].url` in the config TOML.
-- TLS issues against Kiali → try `--kiali-insecure` or `[kiali].insecure = true` for non-production environments.
+- Missing Kiali configuration when `kiali` toolset is enabled → provide `--kiali-url` or set `[toolset_configs.kiali].url` in the config TOML.
+- Invalid URL → ensure `[toolset_configs.kiali].url` is a valid `http(s)://host` URL.
+- TLS issues against Kiali → try `--kiali-insecure` or `[toolset_configs.kiali].insecure = true` for non-production environments.
 
 

pkg/config/config.go

@@ -16,12 +16,6 @@ const (
 	ClusterProviderDisabled   = "disabled"
 )
 
-// KialiOptions is the configuration for the kiali toolset.
-type KialiOptions struct {
-	Url      string `toml:"url,omitempty"`
-	Insecure bool   `toml:"insecure,omitempty"`
-}
-
 // StaticConfig is the configuration for the server.
 // It allows to configure server specific settings and tools to be enabled or disabled.
 type StaticConfig struct {
@@ -74,11 +68,14 @@ type StaticConfig struct {
 	// This map holds raw TOML primitives that will be parsed by registered provider parsers
 	ClusterProviderConfigs map[string]toml.Primitive `toml:"cluster_provider_configs,omitempty"`
 
-	// KialiOptions is the configuration for the kiali toolset.
-	KialiOptions KialiOptions `toml:"kiali,omitempty"`
+	// Toolset-specific configurations
+	// This map holds raw TOML primitives that will be parsed by registered toolset parsers
+	ToolsetConfigs map[string]toml.Primitive `toml:"toolset_configs,omitempty"`
 
 	// Internal: parsed provider configs (not exposed to TOML package)
 	parsedClusterProviderConfigs map[string]ProviderConfig
+	// Internal: parsed toolset configs (not exposed to TOML package)
+	parsedToolsetConfigs map[string]ToolsetConfig
 
 	// Internal: the config.toml directory, to help resolve relative file paths
 	configDirPath string
@@ -136,6 +133,10 @@ func ReadToml(configData []byte, opts ...ReadConfigOpt) (*StaticConfig, error) {
 		return nil, err
 	}
 
+	if err := config.parseToolsetConfigs(md); err != nil {
+		return nil, err
+	}
+
 	return config, nil
 }
 
@@ -172,3 +173,43 @@ func (c *StaticConfig) parseClusterProviderConfigs(md toml.MetaData) error {
 
 	return nil
 }
+
+func (c *StaticConfig) parseToolsetConfigs(md toml.MetaData) error {
+	if c.parsedToolsetConfigs == nil {
+		c.parsedToolsetConfigs = make(map[string]ToolsetConfig, len(c.ToolsetConfigs))
+	}
+
+	ctx := withConfigDirPath(context.Background(), c.configDirPath)
+
+	for name, primitive := range c.ToolsetConfigs {
+		parser, ok := getToolsetConfigParser(name)
+		if !ok {
+			continue
+		}
+
+		toolsetConfig, err := parser(ctx, primitive, md)
+		if err != nil {
+			return fmt.Errorf("failed to parse config for Toolset '%s': %w", name, err)
+		}
+
+		if err := toolsetConfig.Validate(); err != nil {
+			return fmt.Errorf("invalid config file for Toolset '%s': %w", name, err)
+		}
+
+		c.parsedToolsetConfigs[name] = toolsetConfig
+	}
+
+	return nil
+}
+
+func (c *StaticConfig) GetToolsetConfig(name string) (ToolsetConfig, bool) {
+	cfg, ok := c.parsedToolsetConfigs[name]
+	return cfg, ok
+}
+
+func (c *StaticConfig) SetToolsetConfig(name string, cfg ToolsetConfig) {
+	if c.parsedToolsetConfigs == nil {
+		c.parsedToolsetConfigs = make(map[string]ToolsetConfig)
+	}
+	c.parsedToolsetConfigs[name] = cfg
+}

pkg/config/toolset_config.go

@@ -0,0 +1,34 @@
+package config
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/BurntSushi/toml"
+)
+
+// ToolsetConfig is the interface that all toolset-specific configurations must implement.
+// Each toolset registers a factory function to parse its config from TOML primitives
+type ToolsetConfig interface {
+	Validate() error
+}
+
+type ToolsetConfigParser func(ctx context.Context, primitive toml.Primitive, md toml.MetaData) (ToolsetConfig, error)
+
+var (
+	toolsetConfigParsers = make(map[string]ToolsetConfigParser)
+)
+
+func RegisterToolsetConfig(name string, parser ToolsetConfigParser) {
+	if _, exists := toolsetConfigParsers[name]; exists {
+		panic(fmt.Sprintf("toolset config parser already registered for toolset '%s'", name))
+	}
+
+	toolsetConfigParsers[name] = parser
+}
+
+func getToolsetConfigParser(name string) (ToolsetConfigParser, bool) {
+	parser, ok := toolsetConfigParsers[name]
+
+	return parser, ok
+}

pkg/kiali/config.go

@@ -0,0 +1,43 @@
+package kiali
+
+import (
+	"context"
+	"errors"
+	"net/url"
+
+	"github.com/BurntSushi/toml"
+	"github.com/containers/kubernetes-mcp-server/pkg/config"
+)
+
+// Config holds Kiali toolset configuration
+type Config struct {
+	Url      string `toml:"url,omitempty"`
+	Insecure bool   `toml:"insecure,omitempty"`
+}
+
+var _ config.ToolsetConfig = (*Config)(nil)
+
+func (c *Config) Validate() error {
+	if c == nil {
+		return errors.New("kiali config is nil")
+	}
+	if c.Url == "" {
+		return errors.New("kiali-url is required")
+	}
+	if u, err := url.Parse(c.Url); err != nil || u.Scheme == "" || u.Host == "" {
+		return errors.New("kiali-url must be a valid URL")
+	}
+	return nil
+}
+
+func kialiToolsetParser(_ context.Context, primitive toml.Primitive, md toml.MetaData) (config.ToolsetConfig, error) {
+	var cfg Config
+	if err := md.PrimitiveDecode(primitive, &cfg); err != nil {
+		return nil, err
+	}
+	return &cfg, nil
+}
+
+func init() {
+	config.RegisterToolsetConfig("kiali", kialiToolsetParser)
+}

pkg/kiali/kiali_test.go

@@ -11,7 +11,9 @@ import (
 )
 
 func TestValidateAndGetURL_JoinsProperly(t *testing.T) {
-	m := NewManager(&config.StaticConfig{KialiOptions: config.KialiOptions{Url: "https://kiali.example/"}})
+	cfg := config.Default()
+	cfg.SetToolsetConfig("kiali", &Config{Url: "https://kiali.example/"})
+	m := NewManager(cfg)
 	k := m.GetKiali()
 
 	full, err := k.validateAndGetURL("/api/path")
@@ -56,7 +58,9 @@ func TestExecuteRequest_SetsAuthAndCallsServer(t *testing.T) {
 	}))
 	defer srv.Close()
 
-	m := NewManager(&config.StaticConfig{KialiOptions: config.KialiOptions{Url: srv.URL}})
+	cfg := config.Default()
+	cfg.SetToolsetConfig("kiali", &Config{Url: srv.URL})
+	m := NewManager(cfg)
 	m.BearerToken = "token-xyz"
 	k := m.GetKiali()
 	out, err := k.executeRequest(context.Background(), "/api/ping?q=1")

pkg/kiali/manager.go

@@ -13,11 +13,18 @@ type Manager struct {
 }
 
 func NewManager(config *config.StaticConfig) *Manager {
-	return &Manager{
+	m := &Manager{
 		BearerToken:   "",
-		KialiURL:      config.KialiOptions.Url,
-		KialiInsecure: config.KialiOptions.Insecure,
+		KialiURL:      "",
+		KialiInsecure: false,
 	}
+	if cfg, ok := config.GetToolsetConfig("kiali"); ok {
+		if kc, ok := cfg.(*Config); ok && kc != nil {
+			m.KialiURL = kc.Url
+			m.KialiInsecure = kc.Insecure
+		}
+	}
+	return m
 }
 
 func (m *Manager) Derived(_ context.Context) (*Kiali, error) {

pkg/kiali/manager_test.go

@@ -8,21 +8,23 @@ import (
 )
 
 func TestNewManagerUsesConfigFields(t *testing.T) {
-	cfg := &config.StaticConfig{KialiOptions: config.KialiOptions{Url: "https://kiali.example", Insecure: true}}
+	cfg := config.Default()
+	cfg.SetToolsetConfig("kiali", &Config{Url: "https://kiali.example", Insecure: true})
 	m := NewManager(cfg)
 	if m == nil {
 		t.Fatalf("expected manager, got nil")
 	}
-	if m.KialiURL != cfg.KialiOptions.Url {
-		t.Fatalf("expected KialiURL %s, got %s", cfg.KialiOptions.Url, m.KialiURL)
+	if m.KialiURL != "https://kiali.example" {
+		t.Fatalf("expected KialiURL %s, got %s", "https://kiali.example", m.KialiURL)
 	}
-	if m.KialiInsecure != cfg.KialiOptions.Insecure {
-		t.Fatalf("expected KialiInsecure %v, got %v", cfg.KialiOptions.Insecure, m.KialiInsecure)
+	if m.KialiInsecure != true {
+		t.Fatalf("expected KialiInsecure %v, got %v", true, m.KialiInsecure)
 	}
 }
 
 func TestDerivedWithoutAuthorizationReturnsOriginalManager(t *testing.T) {
-	cfg := &config.StaticConfig{KialiOptions: config.KialiOptions{Url: "https://kiali.example"}}
+	cfg := config.Default()
+	cfg.SetToolsetConfig("kiali", &Config{Url: "https://kiali.example"})
 	m := NewManager(cfg)
 	k, err := m.Derived(context.Background())
 	if err != nil {
@@ -34,7 +36,8 @@ func TestDerivedWithoutAuthorizationReturnsOriginalManager(t *testing.T) {
 }
 
 func TestDerivedPreservesURLAndToken(t *testing.T) {
-	cfg := &config.StaticConfig{KialiOptions: config.KialiOptions{Url: "https://kiali.example", Insecure: true}}
+	cfg := config.Default()
+	cfg.SetToolsetConfig("kiali", &Config{Url: "https://kiali.example", Insecure: true})
 	m := NewManager(cfg)
 	m.BearerToken = "token-abc"
 	k, err := m.Derived(context.Background())

pkg/kiali/mesh_test.go

@@ -19,7 +19,9 @@ func TestMeshStatus_CallsGraphWithExpectedQuery(t *testing.T) {
 	}))
 	defer srv.Close()
 
-	m := NewManager(&config.StaticConfig{KialiOptions: config.KialiOptions{Url: srv.URL}})
+	cfg := config.Default()
+	cfg.SetToolsetConfig("kiali", &Config{Url: srv.URL})
+	m := NewManager(cfg)
 	m.BearerToken = "tkn"
 	k := m.GetKiali()
 	out, err := k.MeshStatus(context.Background())

pkg/kubernetes-mcp-server/cmd/root.go

@@ -25,6 +25,7 @@ import (
 
 	"github.com/containers/kubernetes-mcp-server/pkg/config"
 	internalhttp "github.com/containers/kubernetes-mcp-server/pkg/http"
+	"github.com/containers/kubernetes-mcp-server/pkg/kiali"
 	"github.com/containers/kubernetes-mcp-server/pkg/mcp"
 	"github.com/containers/kubernetes-mcp-server/pkg/output"
 	"github.com/containers/kubernetes-mcp-server/pkg/toolsets"
@@ -243,11 +244,8 @@ func (m *MCPServerOptions) loadFlags(cmd *cobra.Command) {
 	if cmd.Flag(flagDisableMultiCluster).Changed && m.DisableMultiCluster {
 		m.StaticConfig.ClusterProviderStrategy = config.ClusterProviderDisabled
 	}
-	if cmd.Flag(flagKialiUrl).Changed {
-		m.StaticConfig.KialiOptions.Url = m.KialiOptions.Url
-	}
-	if cmd.Flag(flagKialiInsecure).Changed {
-		m.StaticConfig.KialiOptions.Insecure = m.KialiOptions.Insecure
+	if cmd.Flag(flagKialiUrl).Changed || cmd.Flag(flagKialiInsecure).Changed {
+		m.StaticConfig.SetToolsetConfig("kiali", &kiali.Config{Url: m.KialiOptions.Url, Insecure: m.KialiOptions.Insecure})
 	}
 }
 
@@ -294,9 +292,15 @@ func (m *MCPServerOptions) Validate() error {
 			klog.Warningf("authorization-url is using http://, this is not recommended production use")
 		}
 	}
-	/* If Kiali tools are enabled, validate the Kiali URL */
-	if slices.Contains(m.StaticConfig.Toolsets, "kiali") && strings.TrimSpace(m.StaticConfig.KialiOptions.Url) == "" {
-		return fmt.Errorf("kiali-url is required when kiali tools are enabled")
+	/* If Kiali tools are enabled, validate Kiali toolset configuration */
+	if slices.Contains(m.StaticConfig.Toolsets, "kiali") {
+		cfg, ok := m.StaticConfig.GetToolsetConfig("kiali")
+		if !ok {
+			return fmt.Errorf("kiali configuration is required when kiali tools are enabled")
+		}
+		if err := cfg.Validate(); err != nil {
+			return fmt.Errorf("invalid kiali configuration: %w", err)
+		}
 	}
 	return nil
 }