feat: add vm_stop tool for KubeVirt VirtualMachines

Implement functionality to stop VirtualMachines by updating their
runStrategy to 'Halted'. This commit includes:

- pkg/kubevirt/vm.go: Add StopVM() function
  - Stops a VM by setting runStrategy to Halted
  - Idempotent operation: checks if VM is already stopped
  - Returns updated VM and boolean indicating if state changed
  - Consistent error handling with StartVM()

- pkg/toolsets/kubevirt/vm/stop/tool.go: MCP tool implementation
  - Input validation for namespace and name parameters
  - Proper error handling and user feedback
  - Provides clear messaging about whether VM was stopped or already halted

The tool gracefully handles already-stopped VMs and provides clear
feedback on whether the VM state changed.

Code was assisted by Cursor AI

Signed-off-by: Karel Simon <ksimon@redhat.com>

Author: ksimon1

pkg/kubevirt/vm.go

@@ -94,3 +94,36 @@ func StartVM(ctx context.Context, dynamicClient dynamic.Interface, namespace, na
 
 	return updatedVM, true, nil
 }
+
+// StopVM stops a VirtualMachine by updating its runStrategy to Halted
+// Returns the updated VM and true if the VM was stopped, false if it was already stopped
+func StopVM(ctx context.Context, dynamicClient dynamic.Interface, namespace, name string) (*unstructured.Unstructured, bool, error) {
+	// Get the current VirtualMachine
+	vm, err := GetVirtualMachine(ctx, dynamicClient, namespace, name)
+	if err != nil {
+		return nil, false, fmt.Errorf("failed to get VirtualMachine: %w", err)
+	}
+
+	currentStrategy, found, err := GetVMRunStrategy(vm)
+	if err != nil {
+		return nil, false, err
+	}
+
+	// Check if already stopped
+	if found && currentStrategy == RunStrategyHalted {
+		return vm, false, nil
+	}
+
+	// Update runStrategy to Halted
+	if err := SetVMRunStrategy(vm, RunStrategyHalted); err != nil {
+		return nil, false, fmt.Errorf("failed to set runStrategy: %w", err)
+	}
+
+	// Update the VM in the cluster
+	updatedVM, err := UpdateVirtualMachine(ctx, dynamicClient, vm)
+	if err != nil {
+		return nil, false, fmt.Errorf("failed to stop VirtualMachine: %w", err)
+	}
+
+	return updatedVM, true, nil
+}

pkg/toolsets/kubevirt/vm/stop/tool.go

@@ -0,0 +1,94 @@
+package stop
+
+import (
+	"fmt"
+
+	"github.com/containers/kubernetes-mcp-server/pkg/api"
+	"github.com/containers/kubernetes-mcp-server/pkg/kubevirt"
+	"github.com/containers/kubernetes-mcp-server/pkg/output"
+	"github.com/google/jsonschema-go/jsonschema"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/utils/ptr"
+)
+
+func Tools() []api.ServerTool {
+	return []api.ServerTool{
+		{
+			Tool: api.Tool{
+				Name:        "vm_stop",
+				Description: "Stop a running VirtualMachine by changing its runStrategy to Halted",
+				InputSchema: &jsonschema.Schema{
+					Type: "object",
+					Properties: map[string]*jsonschema.Schema{
+						"namespace": {
+							Type:        "string",
+							Description: "The namespace of the virtual machine",
+						},
+						"name": {
+							Type:        "string",
+							Description: "The name of the virtual machine to stop",
+						},
+					},
+					Required: []string{"namespace", "name"},
+				},
+				Annotations: api.ToolAnnotations{
+					Title:           "Virtual Machine: Stop",
+					ReadOnlyHint:    ptr.To(false),
+					DestructiveHint: ptr.To(false),
+					IdempotentHint:  ptr.To(true),
+					OpenWorldHint:   ptr.To(false),
+				},
+			},
+			Handler: stop,
+		},
+	}
+}
+
+func stop(params api.ToolHandlerParams) (*api.ToolCallResult, error) {
+	// Parse input parameters
+	namespace, err := getRequiredString(params, "namespace")
+	if err != nil {
+		return api.NewToolCallResult("", err), nil
+	}
+
+	name, err := getRequiredString(params, "name")
+	if err != nil {
+		return api.NewToolCallResult("", err), nil
+	}
+
+	// Stop the VirtualMachine using kubevirt helper
+	dynamicClient := params.AccessControlClientset().DynamicClient()
+	vm, wasRunning, err := kubevirt.StopVM(params.Context, dynamicClient, namespace, name)
+	if err != nil {
+		return api.NewToolCallResult("", err), nil
+	}
+
+	// Generate appropriate message
+	var message string
+	if wasRunning {
+		message = "# VirtualMachine stopped successfully\n"
+	} else {
+		message = fmt.Sprintf("# VirtualMachine '%s' in namespace '%s' is already stopped\n", name, namespace)
+	}
+
+	// Format the output
+	marshalledYaml, err := output.MarshalYaml([]*unstructured.Unstructured{vm})
+	if err != nil {
+		return api.NewToolCallResult("", fmt.Errorf("failed to marshal VirtualMachine: %w", err)), nil
+	}
+
+	return api.NewToolCallResult(message+marshalledYaml, nil), nil
+}
+
+func getRequiredString(params api.ToolHandlerParams, key string) (string, error) {
+	args := params.GetArguments()
+	val, ok := args[key]
+	if !ok {
+		return "", fmt.Errorf("%s parameter required", key)
+	}
+	str, ok := val.(string)
+	if !ok {
+		return "", fmt.Errorf("%s parameter must be a string", key)
+	}
+	return str, nil
+}