Merge branch 'main' into feat/mcp-hub-hybrid-intelligence

Author: victoriacheng15

cmd/mcp-pods/main.go

@@ -51,7 +51,7 @@ func main() {
 		}
 	}()
 
-	telemetry.Info("mcp-pods ready", "tools", []string{"inspect_pods", "describe_pod", "list_pod_events"})
+	telemetry.Info("mcp-pods ready", "tools", []string{"inspect_pods", "describe_pod", "list_pod_events", "get_pod_logs", "delete_pod"})
 
 	sig := <-sigChan
 	telemetry.Info("received signal, shutting down", "signal", sig.String())

cmd/mcp-telemetry/main.go

@@ -3,6 +3,8 @@ package main
 import (
 	"context"
 	"os"
+	"os/signal"
+	"syscall"
 
 	"github.com/modelcontextprotocol/go-sdk/mcp"
 
@@ -53,15 +55,20 @@ func main() {
 
 	internalmcp.RegisterTelemetryTools(server, provider)
 
-	telemetry.Info("mcp-telemetry ready", "tools", []string{"query_metrics", "query_logs", "query_traces", "investigate_incident"})
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
 
-	// Run the server on stdio transport. This is a blocking call.
-	// We run it directly in the main thread for standalone operation.
-	t := &mcp.StdioTransport{}
-	if err := server.Run(ctx, t); err != nil {
-		telemetry.Error("MCP server execution failed", "error", err)
-	}
+	go func() {
+		t := &mcp.StdioTransport{}
+		if err := server.Run(ctx, t); err != nil {
+			telemetry.Error("MCP server execution failed", "error", err)
+		}
+	}()
+
+	telemetry.Info("mcp-telemetry ready", "tools", []string{"query_metrics", "query_logs", "query_traces", "investigate_incident"})
 
-	telemetry.Info("shutting down mcp-telemetry")
+	sig := <-sigChan
+	telemetry.Info("received signal, shutting down", "signal", sig.String())
+	cancel()
 	provider.Close()
 }

docs/decisions/018-domain-isolated-mcp-architecture.md

@@ -18,9 +18,10 @@ Combining infrastructure tools (Kubernetes API) with telemetry tools (LGTM stack
 
 Adopt a **Domain-Isolated MCP Architecture** by splitting agentic capabilities into specialized, standalone binaries:
 
-- **Specialized Servers:** Implement a new dedicated service, **`mcp-pods`**, to handle all infrastructure-related investigations. Future servers (e.g., `mcp-domain`) will follow this pattern.
+- **Specialized Servers:** Implement a new dedicated service, **`mcp-pods`**, to handle all infrastructure-related operations and investigations. This includes diagnostic log retrieval (`get_pod_logs`) and basic remediation (`delete_pod`) alongside resource inspection.
 - **Shared Registry Pattern:** Use a modular registry in `internal/mcp/registry.go` to share protocol logic (JSON-RPC formatting, error handling) while allowing each binary to register only the toolsets it requires.
 - **Standalone Binary Pattern:** Deploy these servers as pure binaries communicating over `stdio`, avoiding host-tier service managers like systemd to improve portability and alignment with future containerized orchestration.
+- **Lifecycle Standardization:** Enforce a unified signal-handling pattern (`os/signal`) across all MCP binaries to ensure reliable telemetry flushing and resource cleanup (e.g., closing provider connections) during server termination.
 
 ## Consequences
 
@@ -39,5 +40,6 @@ Adopt a **Domain-Isolated MCP Architecture** by splitting agentic capabilities i
 
 - [x] **Modular Registry:** Refactored `internal/mcp/registry.go` to support `RegisterTelemetryTools` and `RegisterPodsTools` independently.
 - [x] **Service Isolation:** Verified `mcp-pods` binary successfully executes and connects to the K3s API using `client-go` with pluralized naming conventions.
-- [x] **Tool Fidelity:** Verified `inspect_pods`, `describe_pod`, and `list_pod_events` return high-signal, machine-readable data from the live cluster.
+- [x] **Operational Expansion:** Implemented and verified `get_pod_logs` and `delete_pod` for active troubleshooting and remediation.
+- [x] **Lifecycle Standardization:** Standardized all MCP servers (pods, telemetry) on signal-based graceful shutdown patterns to ensure reliable cleanup.
 - [x] **Systemic Stability:** Confirmed that `mcp-telemetry` remains fully functional and isolated from the infrastructure-level logic.

internal/mcp/providers/pods.go

@@ -99,3 +99,35 @@ func (p *PodsProvider) ListEvents(ctx context.Context, namespace, name string) (
 
 	return filtered, nil
 }
+
+// GetPodLogs retrieves logs from the specified pod/container.
+func (p *PodsProvider) GetPodLogs(ctx context.Context, namespace, name, container string, tailLines int64, previous bool) (string, error) {
+	opts := &corev1.PodLogOptions{
+		Container: container,
+		Previous:  previous,
+	}
+	if tailLines > 0 {
+		opts.TailLines = &tailLines
+	}
+
+	req := p.clientset.CoreV1().Pods(namespace).GetLogs(name, opts)
+	logs, err := req.DoRaw(ctx)
+	if err != nil {
+		return "", fmt.Errorf("failed to get logs for pod %s/%s: %w", name, namespace, err)
+	}
+
+	return string(logs), nil
+}
+
+// DeletePod deletes the specified pod.
+func (p *PodsProvider) DeletePod(ctx context.Context, namespace, name string, gracePeriod *int64) error {
+	opts := metav1.DeleteOptions{
+		GracePeriodSeconds: gracePeriod,
+	}
+	err := p.clientset.CoreV1().Pods(namespace).Delete(ctx, name, opts)
+	if err != nil {
+		return fmt.Errorf("failed to delete pod %s/%s: %w", name, namespace, err)
+	}
+
+	return nil
+}

internal/mcp/providers/pods_test.go

@@ -161,4 +161,42 @@ func TestPodsProvider(t *testing.T) {
 			})
 		}
 	})
+
+	t.Run("DeletePod", func(t *testing.T) {
+		fakePod := &corev1.Pod{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      "delete-me",
+				Namespace: "default",
+			},
+		}
+		clientset := fake.NewSimpleClientset(fakePod)
+		provider := &PodsProvider{clientset: clientset}
+
+		err := provider.DeletePod(context.Background(), "default", "delete-me", nil)
+		if err != nil {
+			t.Errorf("DeletePod() unexpected error: %v", err)
+		}
+
+		err = provider.DeletePod(context.Background(), "default", "ghost-pod", nil)
+		if err == nil {
+			t.Error("DeletePod() expected error for non-existent pod, got nil")
+		}
+	})
+
+	t.Run("GetPodLogs", func(t *testing.T) {
+		fakePod := &corev1.Pod{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      "test-pod",
+				Namespace: "default",
+			},
+		}
+		clientset := fake.NewSimpleClientset(fakePod)
+		provider := &PodsProvider{clientset: clientset}
+
+		// Note: fake clientset's GetLogs doesn't return actual logs, but we can verify it doesn't error
+		_, err := provider.GetPodLogs(context.Background(), "default", "test-pod", "", 10, false)
+		if err != nil {
+			t.Errorf("GetPodLogs() unexpected error: %v", err)
+		}
+	})
 }

internal/mcp/registry.go

@@ -113,7 +113,17 @@ func RegisterPodsTools(server *mcp.Server, provider *providers.PodsProvider) {
 		Description: "List all lifecycle events associated with a specific pod",
 	}, handleListPodEvents(provider))
 
-	telemetry.Info("registered pods tools", "count", 3)
+	mcp.AddTool(server, &mcp.Tool{
+		Name:        "get_pod_logs",
+		Description: "Retrieve logs from a specific pod/container",
+	}, handleGetPodLogs(provider))
+
+	mcp.AddTool(server, &mcp.Tool{
+		Name:        "delete_pod",
+		Description: "Delete a specific pod (useful for restarting stuck pods)",
+	}, handleDeletePod(provider))
+
+	telemetry.Info("registered pods tools", "count", 5)
 }
 
 func handleInspectPods(provider *providers.PodsProvider) mcp.ToolHandlerFor[tools.PodsInput, any] {
@@ -188,6 +198,9 @@ func RegisterHubTools(server *mcp.Server, provider *providers.HubProvider) {
 func handleInspectPlatform(provider *providers.HubProvider) mcp.ToolHandlerFor[tools.HubInput, any] {
 	handler := tools.NewInspectPlatformHandler(provider.InspectPlatform)
 	return func(ctx context.Context, _ *mcp.CallToolRequest, input tools.HubInput) (*mcp.CallToolResult, any, error) {
+func handleGetPodLogs(provider *providers.PodsProvider) mcp.ToolHandlerFor[tools.PodLogsInput, any] {
+	handler := tools.NewGetPodLogsHandler(provider.GetPodLogs)
+	return func(ctx context.Context, _ *mcp.CallToolRequest, input tools.PodLogsInput) (*mcp.CallToolResult, any, error) {
 		result, err := handler.Execute(ctx, input)
 		if err != nil {
 			return nil, nil, err
@@ -223,13 +236,18 @@ func handleListHostServices(provider *providers.HubProvider) mcp.ToolHandlerFor[
 		text, _ := json.Marshal(result)
 		return &mcp.CallToolResult{
 			Content: []mcp.Content{&mcp.TextContent{Text: string(text)}},
+		return &mcp.CallToolResult{
+			Content: []mcp.Content{&mcp.TextContent{Text: result.(string)}},
 		}, nil, nil
 	}
 }
 
 func handleQueryServiceLogs(provider *providers.HubProvider) mcp.ToolHandlerFor[tools.HubInput, any] {
 	handler := tools.NewQueryServiceLogsHandler(provider.QueryServiceLogs)
 	return func(ctx context.Context, _ *mcp.CallToolRequest, input tools.HubInput) (*mcp.CallToolResult, any, error) {
+func handleDeletePod(provider *providers.PodsProvider) mcp.ToolHandlerFor[tools.DeletePodInput, any] {
+	handler := tools.NewDeletePodHandler(provider.DeletePod)
+	return func(ctx context.Context, _ *mcp.CallToolRequest, input tools.DeletePodInput) (*mcp.CallToolResult, any, error) {
 		result, err := handler.Execute(ctx, input)
 		if err != nil {
 			return nil, nil, err

internal/mcp/tools/pods.go

@@ -75,3 +75,49 @@ func NewListPodEventsHandler(listEventsFn func(ctx context.Context, namespace, n
 func (h *ListPodEventsHandler) Execute(ctx context.Context, input PodsInput) (interface{}, error) {
 	return h.listEventsFn(ctx, input.Namespace, input.Name)
 }
+
+// PodLogsInput is the input for getting pod logs.
+type PodLogsInput struct {
+	Namespace string `json:"namespace"`
+	Name      string `json:"name"`
+	Container string `json:"container,omitempty"`
+	TailLines int64  `json:"tail_lines,omitempty"`
+	Previous  bool   `json:"previous,omitempty"`
+}
+
+// GetPodLogsHandler handles retrieving logs for a pod.
+type GetPodLogsHandler struct {
+	getLogsFn func(ctx context.Context, namespace, name, container string, tailLines int64, previous bool) (string, error)
+}
+
+func NewGetPodLogsHandler(getLogsFn func(ctx context.Context, namespace, name, container string, tailLines int64, previous bool) (string, error)) *GetPodLogsHandler {
+	return &GetPodLogsHandler{getLogsFn: getLogsFn}
+}
+
+func (h *GetPodLogsHandler) Execute(ctx context.Context, input PodLogsInput) (interface{}, error) {
+	return h.getLogsFn(ctx, input.Namespace, input.Name, input.Container, input.TailLines, input.Previous)
+}
+
+// DeletePodInput is the input for deleting a pod.
+type DeletePodInput struct {
+	Namespace    string `json:"namespace"`
+	Name         string `json:"name"`
+	GraceSeconds *int64 `json:"grace_seconds,omitempty"`
+}
+
+// DeletePodHandler handles deleting a pod.
+type DeletePodHandler struct {
+	deleteFn func(ctx context.Context, namespace, name string, gracePeriod *int64) error
+}
+
+func NewDeletePodHandler(deleteFn func(ctx context.Context, namespace, name string, gracePeriod *int64) error) *DeletePodHandler {
+	return &DeletePodHandler{deleteFn: deleteFn}
+}
+
+func (h *DeletePodHandler) Execute(ctx context.Context, input DeletePodInput) (interface{}, error) {
+	err := h.deleteFn(ctx, input.Namespace, input.Name, input.GraceSeconds)
+	if err != nil {
+		return nil, err
+	}
+	return map[string]string{"status": "deleted", "pod": input.Name, "namespace": input.Namespace}, nil
+}

internal/mcp/tools/pods_test.go

@@ -135,3 +135,73 @@ func TestListPodEventsHandler_Execute(t *testing.T) {
 		})
 	}
 }
+
+func TestGetPodLogsHandler_Execute(t *testing.T) {
+	tests := []struct {
+		name      string
+		getLogsFn func(ctx context.Context, namespace, name, container string, tailLines int64, previous bool) (string, error)
+		wantErr   bool
+	}{
+		{
+			name: "successful logs get",
+			getLogsFn: func(ctx context.Context, namespace, name, container string, tailLines int64, previous bool) (string, error) {
+				return "logs", nil
+			},
+			wantErr: false,
+		},
+		{
+			name: "api error",
+			getLogsFn: func(ctx context.Context, namespace, name, container string, tailLines int64, previous bool) (string, error) {
+				return "", errors.New("api error")
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			h := NewGetPodLogsHandler(tt.getLogsFn)
+			got, err := h.Execute(context.Background(), PodLogsInput{Namespace: "default", Name: "test-pod"})
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Execute() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !tt.wantErr && got.(string) != "logs" {
+				t.Errorf("Execute() got = %v, want %v", got, "logs")
+			}
+		})
+	}
+}
+
+func TestDeletePodHandler_Execute(t *testing.T) {
+	tests := []struct {
+		name     string
+		deleteFn func(ctx context.Context, namespace, name string, gracePeriod *int64) error
+		wantErr  bool
+	}{
+		{
+			name: "successful delete",
+			deleteFn: func(ctx context.Context, namespace, name string, gracePeriod *int64) error {
+				return nil
+			},
+			wantErr: false,
+		},
+		{
+			name: "api error",
+			deleteFn: func(ctx context.Context, namespace, name string, gracePeriod *int64) error {
+				return errors.New("api error")
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			h := NewDeletePodHandler(tt.deleteFn)
+			_, err := h.Execute(context.Background(), DeletePodInput{Namespace: "default", Name: "test-pod"})
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Execute() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}