feat(output): configurable output architecture

manusa · web-flow · commit 155fe6847f5c · 2025-06-11T12:13:23.000+02:00
diff --git a/pkg/kubernetes-mcp-server/cmd/root.go b/pkg/kubernetes-mcp-server/cmd/root.go
@@ -5,6 +5,7 @@ import (
 	"flag"
 	"fmt"
 	"github.com/manusa/kubernetes-mcp-server/pkg/mcp"
+	"github.com/manusa/kubernetes-mcp-server/pkg/output"
 	"github.com/manusa/kubernetes-mcp-server/pkg/version"
 	"github.com/mark3labs/mcp-go/server"
 	"github.com/spf13/cobra"
@@ -46,8 +47,14 @@ Kubernetes Model Context Protocol (MCP) server
 			fmt.Printf("Invalid profile name: %s, valid names are: %s\n", viper.GetString("profile"), strings.Join(mcp.ProfileNames, ", "))
 			os.Exit(1)
 		}
+		o := output.FromString(viper.GetString("output"))
+		if o == nil {
+			fmt.Printf("Invalid output name: %s, valid names are: %s\n", viper.GetString("output"), strings.Join(output.Names, ", "))
+			os.Exit(1)
+		}
 		klog.V(1).Info("Starting kubernetes-mcp-server")
 		klog.V(1).Infof(" - Profile: %s", profile.GetName())
+		klog.V(1).Infof(" - Output: %s", o.GetName())
 		klog.V(1).Infof(" - Read-only mode: %t", viper.GetBool("read-only"))
 		klog.V(1).Infof(" - Disable destructive tools: %t", viper.GetBool("disable-destructive"))
 		if viper.GetBool("version") {
@@ -56,6 +63,7 @@ Kubernetes Model Context Protocol (MCP) server
 		}
 		mcpServer, err := mcp.NewSever(mcp.Configuration{
 			Profile:            profile,
+			Output:             o,
 			ReadOnly:           viper.GetBool("read-only"),
 			DisableDestructive: viper.GetBool("disable-destructive"),
 			Kubeconfig:         viper.GetString("kubeconfig"),
@@ -121,14 +129,21 @@ func (p *profileFlag) Type() string {
 	return "profile"
 }
 
-func init() {
+// flagInit initializes the flags for the root command.
+// Exposed for testing purposes.
+func flagInit() {
 	rootCmd.Flags().BoolP("version", "v", false, "Print version information and quit")
 	rootCmd.Flags().IntP("log-level", "", 0, "Set the log level (from 0 to 9)")
 	rootCmd.Flags().IntP("sse-port", "", 0, "Start a SSE server on the specified port")
 	rootCmd.Flags().StringP("sse-base-url", "", "", "SSE public base URL to use when sending the endpoint message (e.g. https://example.com)")
 	rootCmd.Flags().StringP("kubeconfig", "", "", "Path to the kubeconfig file to use for authentication")
-	rootCmd.Flags().String("profile", "full", "MCP profile to use (one of: "+strings.Join(mcp.ProfileNames, ", ")+")")
+	rootCmd.Flags().String("profile", "full", "MCP profile to use (one of: "+strings.Join(mcp.ProfileNames, ", ")+") default is full")
+	rootCmd.Flags().String("output", "yaml", "Output format for resources (one of: "+strings.Join(output.Names, ", ")+") default is yaml")
 	rootCmd.Flags().Bool("read-only", false, "If true, only tools annotated with readOnlyHint=true are exposed")
 	rootCmd.Flags().Bool("disable-destructive", false, "If true, tools annotated with destructiveHint=true are disabled")
 	_ = viper.BindPFlags(rootCmd.Flags())
 }
+
+func init() {
+	flagInit()
+}
diff --git a/pkg/kubernetes-mcp-server/cmd/root_test.go b/pkg/kubernetes-mcp-server/cmd/root_test.go
@@ -22,22 +22,51 @@ func captureOutput(f func() error) (string, error) {
 
 func TestVersion(t *testing.T) {
 	rootCmd.SetArgs([]string{"--version"})
+	rootCmd.ResetFlags()
+	flagInit()
 	version, err := captureOutput(rootCmd.Execute)
 	if version != "0.0.0\n" {
 		t.Fatalf("Expected version 0.0.0, got %s %v", version, err)
 	}
 }
 
-func TestDefaultProfile(t *testing.T) {
-	rootCmd.SetArgs([]string{"--version", "--log-level=1"})
-	out, err := captureOutput(rootCmd.Execute)
-	if !strings.Contains(out, "- Profile: full") {
-		t.Fatalf("Expected profile 'full', got %s %v", out, err)
-	}
+func TestProfile(t *testing.T) {
+	t.Run("default", func(t *testing.T) {
+		rootCmd.SetArgs([]string{"--version", "--log-level=1"})
+		rootCmd.ResetFlags()
+		flagInit()
+		out, err := captureOutput(rootCmd.Execute)
+		if !strings.Contains(out, "- Profile: full") {
+			t.Fatalf("Expected profile 'full', got %s %v", out, err)
+		}
+	})
+}
+
+func TestOutput(t *testing.T) {
+	t.Run("available", func(t *testing.T) {
+		rootCmd.SetArgs([]string{"--help"})
+		rootCmd.ResetFlags()
+		flagInit()
+		out, err := captureOutput(rootCmd.Execute)
+		if !strings.Contains(out, "Output format for resources (one of: yaml)") {
+			t.Fatalf("Expected all available outputs, got %s %v", out, err)
+		}
+	})
+	t.Run("default", func(t *testing.T) {
+		rootCmd.SetArgs([]string{"--version", "--log-level=1"})
+		rootCmd.ResetFlags()
+		flagInit()
+		out, err := captureOutput(rootCmd.Execute)
+		if !strings.Contains(out, "- Output: yaml") {
+			t.Fatalf("Expected output 'yaml', got %s %v", out, err)
+		}
+	})
 }
 
 func TestDefaultReadOnly(t *testing.T) {
 	rootCmd.SetArgs([]string{"--version", "--log-level=1"})
+	rootCmd.ResetFlags()
+	flagInit()
 	out, err := captureOutput(rootCmd.Execute)
 	if !strings.Contains(out, " - Read-only mode: false") {
 		t.Fatalf("Expected read-only mode false, got %s %v", out, err)
@@ -46,6 +75,8 @@ func TestDefaultReadOnly(t *testing.T) {
 
 func TestDefaultDisableDestructive(t *testing.T) {
 	rootCmd.SetArgs([]string{"--version", "--log-level=1"})
+	rootCmd.ResetFlags()
+	flagInit()
 	out, err := captureOutput(rootCmd.Execute)
 	if !strings.Contains(out, " - Disable destructive tools: false") {
 		t.Fatalf("Expected disable destructive false, got %s %v", out, err)
diff --git a/pkg/kubernetes/configuration.go b/pkg/kubernetes/configuration.go
@@ -1,6 +1,7 @@
 package kubernetes
 
 import (
+	"github.com/manusa/kubernetes-mcp-server/pkg/output"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"
 	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
@@ -109,5 +110,5 @@ func (k *Kubernetes) ConfigurationView(minify bool) (string, error) {
 	if err != nil {
 		return "", err
 	}
-	return marshal(convertedObj)
+	return output.MarshalYaml(convertedObj)
 }
diff --git a/pkg/kubernetes/events.go b/pkg/kubernetes/events.go
@@ -3,6 +3,7 @@ package kubernetes
 import (
 	"context"
 	"fmt"
+	"github.com/manusa/kubernetes-mcp-server/pkg/output"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -46,7 +47,7 @@ func (k *Kubernetes) EventsList(ctx context.Context, namespace string) (string,
 			"Message": strings.TrimSpace(event.Message),
 		})
 	}
-	yamlEvents, err := marshal(eventMap)
+	yamlEvents, err := output.MarshalYaml(eventMap)
 	if err != nil {
 		return "", err
 	}
diff --git a/pkg/kubernetes/kubernetes.go b/pkg/kubernetes/kubernetes.go
@@ -6,7 +6,6 @@ import (
 	"github.com/manusa/kubernetes-mcp-server/pkg/helm"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/meta"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/discovery"
 	"k8s.io/client-go/discovery/cached/memory"
@@ -18,7 +17,6 @@ import (
 	"k8s.io/client-go/tools/clientcmd"
 	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
 	"k8s.io/klog/v2"
-	"sigs.k8s.io/yaml"
 	"strings"
 )
 
@@ -164,25 +162,3 @@ func (k *Kubernetes) Derived(ctx context.Context) *Kubernetes {
 	derived.Helm = helm.NewHelm(derived)
 	return derived
 }
-
-func marshal(v any) (string, error) {
-	switch t := v.(type) {
-	case []unstructured.Unstructured:
-		for i := range t {
-			t[i].SetManagedFields(nil)
-		}
-	case []*unstructured.Unstructured:
-		for i := range t {
-			t[i].SetManagedFields(nil)
-		}
-	case unstructured.Unstructured:
-		t.SetManagedFields(nil)
-	case *unstructured.Unstructured:
-		t.SetManagedFields(nil)
-	}
-	ret, err := yaml.Marshal(v)
-	if err != nil {
-		return "", err
-	}
-	return string(ret), nil
-}
diff --git a/pkg/kubernetes/namespaces.go b/pkg/kubernetes/namespaces.go
@@ -2,16 +2,17 @@ package kubernetes
 
 import (
 	"context"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 )
 
-func (k *Kubernetes) NamespacesList(ctx context.Context) (string, error) {
+func (k *Kubernetes) NamespacesList(ctx context.Context) ([]unstructured.Unstructured, error) {
 	return k.ResourcesList(ctx, &schema.GroupVersionKind{
 		Group: "", Version: "v1", Kind: "Namespace",
 	}, "")
 }
 
-func (k *Kubernetes) ProjectsList(ctx context.Context) (string, error) {
+func (k *Kubernetes) ProjectsList(ctx context.Context) ([]unstructured.Unstructured, error) {
 	return k.ResourcesList(ctx, &schema.GroupVersionKind{
 		Group: "project.openshift.io", Version: "v1", Kind: "Project",
 	}, "")
diff --git a/pkg/kubernetes/pods.go b/pkg/kubernetes/pods.go
@@ -18,19 +18,19 @@ import (
 	"k8s.io/client-go/tools/remotecommand"
 )
 
-func (k *Kubernetes) PodsListInAllNamespaces(ctx context.Context, labelSelector string) (string, error) {
+func (k *Kubernetes) PodsListInAllNamespaces(ctx context.Context, labelSelector string) ([]unstructured.Unstructured, error) {
 	return k.ResourcesList(ctx, &schema.GroupVersionKind{
 		Group: "", Version: "v1", Kind: "Pod",
 	}, "", labelSelector)
 }
 
-func (k *Kubernetes) PodsListInNamespace(ctx context.Context, namespace string, labelSelector string) (string, error) {
+func (k *Kubernetes) PodsListInNamespace(ctx context.Context, namespace string, labelSelector string) ([]unstructured.Unstructured, error) {
 	return k.ResourcesList(ctx, &schema.GroupVersionKind{
 		Group: "", Version: "v1", Kind: "Pod",
 	}, namespace, labelSelector)
 }
 
-func (k *Kubernetes) PodsGet(ctx context.Context, namespace, name string) (string, error) {
+func (k *Kubernetes) PodsGet(ctx context.Context, namespace, name string) (*unstructured.Unstructured, error) {
 	return k.ResourcesGet(ctx, &schema.GroupVersionKind{
 		Group: "", Version: "v1", Kind: "Pod",
 	}, k.NamespaceOrDefault(namespace), name)
diff --git a/pkg/kubernetes/resources.go b/pkg/kubernetes/resources.go
@@ -2,6 +2,7 @@ package kubernetes
 
 import (
 	"context"
+	"github.com/manusa/kubernetes-mcp-server/pkg/output"
 	"regexp"
 	"strings"
 
@@ -20,32 +21,28 @@ const (
 	AppKubernetesPartOf    = "app.kubernetes.io/part-of"
 )
 
-func (k *Kubernetes) ResourcesList(ctx context.Context, gvk *schema.GroupVersionKind, namespace string, labelSelector ...string) (string, error) {
+func (k *Kubernetes) ResourcesList(ctx context.Context, gvk *schema.GroupVersionKind, namespace string, labelSelector ...string) ([]unstructured.Unstructured, error) {
 	var selector string
 	if len(labelSelector) > 0 {
 		selector = labelSelector[0]
 	}
 	rl, err := k.resourcesList(ctx, gvk, namespace, selector)
 	if err != nil {
-		return "", err
+		return nil, err
 	}
-	return marshal(rl.Items)
+	return rl.Items, nil
 }
 
-func (k *Kubernetes) ResourcesGet(ctx context.Context, gvk *schema.GroupVersionKind, namespace, name string) (string, error) {
+func (k *Kubernetes) ResourcesGet(ctx context.Context, gvk *schema.GroupVersionKind, namespace, name string) (*unstructured.Unstructured, error) {
 	gvr, err := k.resourceFor(gvk)
 	if err != nil {
-		return "", err
+		return nil, err
 	}
 	// If it's a namespaced resource and namespace wasn't provided, try to use the default configured one
 	if namespaced, nsErr := k.isNamespaced(gvk); nsErr == nil && namespaced {
 		namespace = k.NamespaceOrDefault(namespace)
 	}
-	rg, err := k.dynamicClient.Resource(*gvr).Namespace(namespace).Get(ctx, name, metav1.GetOptions{})
-	if err != nil {
-		return "", err
-	}
-	return marshal(rg)
+	return k.dynamicClient.Resource(*gvr).Namespace(namespace).Get(ctx, name, metav1.GetOptions{})
 }
 
 func (k *Kubernetes) ResourcesCreateOrUpdate(ctx context.Context, resource string) (string, error) {
@@ -112,7 +109,7 @@ func (k *Kubernetes) resourcesCreateOrUpdate(ctx context.Context, resources []*u
 			k.deferredDiscoveryRESTMapper.Reset()
 		}
 	}
-	marshalledYaml, err := marshal(resources)
+	marshalledYaml, err := output.MarshalYaml(resources)
 	if err != nil {
 		return "", err
 	}
diff --git a/pkg/mcp/common_test.go b/pkg/mcp/common_test.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"github.com/manusa/kubernetes-mcp-server/pkg/output"
 	"github.com/mark3labs/mcp-go/client"
 	"github.com/mark3labs/mcp-go/client/transport"
 	"github.com/mark3labs/mcp-go/mcp"
@@ -96,6 +97,7 @@ func TestMain(m *testing.M) {
 
 type mcpContext struct {
 	profile            Profile
+	output             output.Output
 	readOnly           bool
 	disableDestructive bool
 	clientOptions      []transport.ClientOption
@@ -117,11 +119,17 @@ func (c *mcpContext) beforeEach(t *testing.T) {
 	if c.profile == nil {
 		c.profile = &FullProfile{}
 	}
+	if c.output == nil {
+		c.output = &output.YamlOutput{}
+	}
 	if c.before != nil {
 		c.before(c)
 	}
 	if c.mcpServer, err = NewSever(Configuration{
-		Profile: c.profile, ReadOnly: c.readOnly, DisableDestructive: c.disableDestructive,
+		Profile:            c.profile,
+		Output:             c.output,
+		ReadOnly:           c.readOnly,
+		DisableDestructive: c.disableDestructive,
 	}); err != nil {
 		t.Fatal(err)
 		return
diff --git a/pkg/mcp/mcp.go b/pkg/mcp/mcp.go
@@ -3,6 +3,7 @@ package mcp
 import (
 	"context"
 	"github.com/manusa/kubernetes-mcp-server/pkg/kubernetes"
+	"github.com/manusa/kubernetes-mcp-server/pkg/output"
 	"github.com/manusa/kubernetes-mcp-server/pkg/version"
 	"github.com/mark3labs/mcp-go/mcp"
 	"github.com/mark3labs/mcp-go/server"
@@ -11,6 +12,7 @@ import (
 
 type Configuration struct {
 	Profile Profile
+	Output  output.Output
 	// When true, expose only tools annotated with readOnlyHint=true
 	ReadOnly bool
 	// When true, disable tools annotated with destructiveHint=true
diff --git a/pkg/mcp/namespaces.go b/pkg/mcp/namespaces.go
@@ -37,15 +37,15 @@ func (s *Server) initNamespaces() []server.ServerTool {
 func (s *Server) namespacesList(ctx context.Context, _ mcp.CallToolRequest) (*mcp.CallToolResult, error) {
 	ret, err := s.k.Derived(ctx).NamespacesList(ctx)
 	if err != nil {
-		err = fmt.Errorf("failed to list namespaces: %v", err)
+		return NewTextResult("", fmt.Errorf("failed to list namespaces: %v", err)), nil
 	}
-	return NewTextResult(ret, err), nil
+	return NewTextResult(s.configuration.Output.PrintObj(ret)), nil
 }
 
 func (s *Server) projectsList(ctx context.Context, _ mcp.CallToolRequest) (*mcp.CallToolResult, error) {
 	ret, err := s.k.Derived(ctx).ProjectsList(ctx)
 	if err != nil {
-		err = fmt.Errorf("failed to list projects: %v", err)
+		return NewTextResult("", fmt.Errorf("failed to list projects: %v", err)), nil
 	}
-	return NewTextResult(ret, err), nil
+	return NewTextResult(s.configuration.Output.PrintObj(ret)), nil
 }
diff --git a/pkg/mcp/pods.go b/pkg/mcp/pods.go
@@ -114,7 +114,7 @@ func (s *Server) podsListInAllNamespaces(ctx context.Context, ctr mcp.CallToolRe
 	if err != nil {
 		return NewTextResult("", fmt.Errorf("failed to list pods in all namespaces: %v", err)), nil
 	}
-	return NewTextResult(ret, err), nil
+	return NewTextResult(s.configuration.Output.PrintObj(ret)), nil
 }
 
 func (s *Server) podsListInNamespace(ctx context.Context, ctr mcp.CallToolRequest) (*mcp.CallToolResult, error) {
@@ -131,7 +131,7 @@ func (s *Server) podsListInNamespace(ctx context.Context, ctr mcp.CallToolReques
 	if err != nil {
 		return NewTextResult("", fmt.Errorf("failed to list pods in namespace %s: %v", ns, err)), nil
 	}
-	return NewTextResult(ret, err), nil
+	return NewTextResult(s.configuration.Output.PrintObj(ret)), nil
 }
 
 func (s *Server) podsGet(ctx context.Context, ctr mcp.CallToolRequest) (*mcp.CallToolResult, error) {
@@ -147,7 +147,7 @@ func (s *Server) podsGet(ctx context.Context, ctr mcp.CallToolRequest) (*mcp.Cal
 	if err != nil {
 		return NewTextResult("", fmt.Errorf("failed to get pod %s in namespace %s: %v", name, ns, err)), nil
 	}
-	return NewTextResult(ret, err), nil
+	return NewTextResult(s.configuration.Output.PrintObj(ret)), nil
 }
 
 func (s *Server) podsDelete(ctx context.Context, ctr mcp.CallToolRequest) (*mcp.CallToolResult, error) {
diff --git a/pkg/mcp/pods_test.go b/pkg/mcp/pods_test.go
diff --git a/pkg/mcp/profiles.go b/pkg/mcp/profiles.go
diff --git a/pkg/mcp/resources.go b/pkg/mcp/resources.go
diff --git a/pkg/output/output.go b/pkg/output/output.go

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`package kubernetes`
`2`	`2`
`3`	`3`	`import (`
	`4`	`+ "github.com/manusa/kubernetes-mcp-server/pkg/output"`
`4`	`5`	`"k8s.io/client-go/rest"`
`5`	`6`	`"k8s.io/client-go/tools/clientcmd"`
`6`	`7`	`clientcmdapi "k8s.io/client-go/tools/clientcmd/api"`
`@@ -109,5 +110,5 @@ func (k *Kubernetes) ConfigurationView(minify bool) (string, error) {`
`109`	`110`	`if err != nil {`
`110`	`111`	`return "", err`
`111`	`112`	`}`
`112`		`- return marshal(convertedObj)`
	`113`	`+ return output.MarshalYaml(convertedObj)`
`113`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@ package kubernetes`
`2`	`2`
`3`	`3`	`import (`
`4`	`4`	`"context"`
	`5`	`+ "github.com/manusa/kubernetes-mcp-server/pkg/output"`
`5`	`6`	`"regexp"`
`6`	`7`	`"strings"`
`7`	`8`
`@@ -20,32 +21,28 @@ const (`
`20`	`21`	`AppKubernetesPartOf = "app.kubernetes.io/part-of"`
`21`	`22`	`)`
`22`	`23`
`23`		`-func (k Kubernetes) ResourcesList(ctx context.Context, gvk schema.GroupVersionKind, namespace string, labelSelector ...string) (string, error) {`
	`24`	`+func (k Kubernetes) ResourcesList(ctx context.Context, gvk schema.GroupVersionKind, namespace string, labelSelector ...string) ([]unstructured.Unstructured, error) {`
`24`	`25`	`var selector string`
`25`	`26`	`if len(labelSelector) > 0 {`
`26`	`27`	`selector = labelSelector[0]`
`27`	`28`	`}`
`28`	`29`	`rl, err := k.resourcesList(ctx, gvk, namespace, selector)`
`29`	`30`	`if err != nil {`
`30`		`- return "", err`
	`31`	`+ return nil, err`
`31`	`32`	`}`
`32`		`- return marshal(rl.Items)`
	`33`	`+ return rl.Items, nil`
`33`	`34`	`}`
`34`	`35`
`35`		`-func (k Kubernetes) ResourcesGet(ctx context.Context, gvk schema.GroupVersionKind, namespace, name string) (string, error) {`
	`36`	`+func (k Kubernetes) ResourcesGet(ctx context.Context, gvk schema.GroupVersionKind, namespace, name string) (*unstructured.Unstructured, error) {`
`36`	`37`	`gvr, err := k.resourceFor(gvk)`
`37`	`38`	`if err != nil {`
`38`		`- return "", err`
	`39`	`+ return nil, err`
`39`	`40`	`}`
`40`	`41`	`// If it's a namespaced resource and namespace wasn't provided, try to use the default configured one`
`41`	`42`	`if namespaced, nsErr := k.isNamespaced(gvk); nsErr == nil && namespaced {`
`42`	`43`	`namespace = k.NamespaceOrDefault(namespace)`
`43`	`44`	`}`
`44`		`- rg, err := k.dynamicClient.Resource(*gvr).Namespace(namespace).Get(ctx, name, metav1.GetOptions{})`
`45`		`- if err != nil {`
`46`		`- return "", err`
`47`		`- }`
`48`		`- return marshal(rg)`
	`45`	`+ return k.dynamicClient.Resource(*gvr).Namespace(namespace).Get(ctx, name, metav1.GetOptions{})`
`49`	`46`	`}`
`50`	`47`
`51`	`48`	`func (k *Kubernetes) ResourcesCreateOrUpdate(ctx context.Context, resource string) (string, error) {`
`@@ -112,7 +109,7 @@ func (k Kubernetes) resourcesCreateOrUpdate(ctx context.Context, resources []u`
`112`	`109`	`k.deferredDiscoveryRESTMapper.Reset()`
`113`	`110`	`}`
`114`	`111`	`}`
`115`		`- marshalledYaml, err := marshal(resources)`
	`112`	`+ marshalledYaml, err := output.MarshalYaml(resources)`
`116`	`113`	`if err != nil {`
`117`	`114`	`return "", err`
`118`	`115`	`}`