feat: add vm_restart tool for KubeVirt VirtualMachines

Implement functionality to restart VirtualMachines by performing a
stop-start sequence. This commit includes:

- pkg/kubevirt/vm.go: Add RestartVM() function
  - Restarts a VM by setting runStrategy to Halted then Always
  - Performs two updates: stop then start
  - Non-idempotent: always executes the restart sequence
  - Ensures VM cycles through complete stop/start for clean restart

- pkg/toolsets/kubevirt/vm/restart/tool.go: MCP tool implementation
  - Input validation for namespace and name parameters
  - Proper error handling for both stop and start phases
  - Returns updated VM YAML showing final state

The restart operation ensures VMs cycle through a full stop/start
sequence rather than just signaling a restart, providing more
reliable VM reinitialization.

Code was assisted by Cursor AI

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

Author: ksimon1

pkg/kubevirt/vm.go

@@ -127,3 +127,34 @@ func StopVM(ctx context.Context, dynamicClient dynamic.Interface, namespace, nam
 
 	return updatedVM, true, nil
 }
+
+// RestartVM restarts a VirtualMachine by temporarily setting runStrategy to Halted then back to Always
+func RestartVM(ctx context.Context, dynamicClient dynamic.Interface, namespace, name string) (*unstructured.Unstructured, error) {
+	// Get the current VirtualMachine
+	vm, err := GetVirtualMachine(ctx, dynamicClient, namespace, name)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get VirtualMachine: %w", err)
+	}
+
+	// Stop the VM first
+	if err := SetVMRunStrategy(vm, RunStrategyHalted); err != nil {
+		return nil, fmt.Errorf("failed to set runStrategy to Halted: %w", err)
+	}
+
+	vm, err = UpdateVirtualMachine(ctx, dynamicClient, vm)
+	if err != nil {
+		return nil, fmt.Errorf("failed to stop VirtualMachine: %w", err)
+	}
+
+	// Start the VM again
+	if err := SetVMRunStrategy(vm, RunStrategyAlways); err != nil {
+		return nil, fmt.Errorf("failed to set runStrategy to Always: %w", err)
+	}
+
+	updatedVM, err := UpdateVirtualMachine(ctx, dynamicClient, vm)
+	if err != nil {
+		return nil, fmt.Errorf("failed to start VirtualMachine: %w", err)
+	}
+
+	return updatedVM, nil
+}

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

@@ -0,0 +1,86 @@
+package restart
+
+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_restart",
+				Description: "Restart a VirtualMachine using the /restart subresource API",
+				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 restart",
+						},
+					},
+					Required: []string{"namespace", "name"},
+				},
+				Annotations: api.ToolAnnotations{
+					Title:           "Virtual Machine: Restart",
+					ReadOnlyHint:    ptr.To(false),
+					DestructiveHint: ptr.To(false),
+					IdempotentHint:  ptr.To(false),
+					OpenWorldHint:   ptr.To(false),
+				},
+			},
+			Handler: restart,
+		},
+	}
+}
+
+func restart(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
+	}
+
+	// Restart the VirtualMachine using kubevirt helper
+	dynamicClient := params.AccessControlClientset().DynamicClient()
+	vm, err := kubevirt.RestartVM(params.Context, dynamicClient, namespace, name)
+	if err != nil {
+		return api.NewToolCallResult("", err), nil
+	}
+
+	// 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("# VirtualMachine restarted successfully\n"+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
+}