feat: add vm_start tool for KubeVirt VirtualMachines

Implement functionality to start VirtualMachines by updating their
runStrategy to 'Always'. This commit includes:

- pkg/kubevirt/vm.go: Core helper functions and types
  - VirtualMachine GVK/GVR constants
  - RunStrategy type with Always/Halted constants
  - GetVirtualMachine() - retrieve a VM from the cluster
  - GetVMRunStrategy() - get current runStrategy from a VM
  - SetVMRunStrategy() - set runStrategy on a VM
  - UpdateVirtualMachine() - update a VM in the cluster
  - StartVM() - start a VM (idempotent, checks if already running)

- pkg/toolsets/kubevirt/vm/start/tool.go: MCP tool implementation
  - Input validation for namespace and name parameters
  - Proper error handling and user feedback
  - Returns updated VM YAML on success

The implementation uses the Kubernetes dynamic client pattern consistent
with the existing vm_create tool.

Code was assisted by Cursor AI

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

Author: ksimon1

pkg/kubevirt/vm.go

@@ -0,0 +1,96 @@
+package kubevirt
+
+import (
+	"context"
+	"fmt"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/dynamic"
+)
+
+// RunStrategy represents the run strategy for a VirtualMachine
+type RunStrategy string
+
+const (
+	RunStrategyAlways RunStrategy = "Always"
+	RunStrategyHalted RunStrategy = "Halted"
+)
+
+var (
+	// VirtualMachineGVK is the GroupVersionKind for VirtualMachine resources
+	VirtualMachineGVK = schema.GroupVersionKind{
+		Group:   "kubevirt.io",
+		Version: "v1",
+		Kind:    "VirtualMachine",
+	}
+
+	// VirtualMachineGVR is the GroupVersionResource for VirtualMachine resources
+	VirtualMachineGVR = schema.GroupVersionResource{
+		Group:    "kubevirt.io",
+		Version:  "v1",
+		Resource: "virtualmachines",
+	}
+)
+
+// GetVirtualMachine retrieves a VirtualMachine by namespace and name
+func GetVirtualMachine(ctx context.Context, client dynamic.Interface, namespace, name string) (*unstructured.Unstructured, error) {
+	return client.Resource(VirtualMachineGVR).Namespace(namespace).Get(ctx, name, metav1.GetOptions{})
+}
+
+// GetVMRunStrategy retrieves the current runStrategy from a VirtualMachine
+// Returns the strategy, whether it was found, and any error
+func GetVMRunStrategy(vm *unstructured.Unstructured) (RunStrategy, bool, error) {
+	strategy, found, err := unstructured.NestedString(vm.Object, "spec", "runStrategy")
+	if err != nil {
+		return "", false, fmt.Errorf("failed to read runStrategy: %w", err)
+	}
+
+	return RunStrategy(strategy), found, nil
+}
+
+// SetVMRunStrategy sets the runStrategy on a VirtualMachine
+func SetVMRunStrategy(vm *unstructured.Unstructured, strategy RunStrategy) error {
+	return unstructured.SetNestedField(vm.Object, string(strategy), "spec", "runStrategy")
+}
+
+// UpdateVirtualMachine updates a VirtualMachine in the cluster
+func UpdateVirtualMachine(ctx context.Context, client dynamic.Interface, vm *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+	return client.Resource(VirtualMachineGVR).
+		Namespace(vm.GetNamespace()).
+		Update(ctx, vm, metav1.UpdateOptions{})
+}
+
+// StartVM starts a VirtualMachine by updating its runStrategy to Always
+// Returns the updated VM and true if the VM was started, false if it was already running
+func StartVM(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 running
+	if found && currentStrategy == RunStrategyAlways {
+		return vm, false, nil
+	}
+
+	// Update runStrategy to Always
+	if err := SetVMRunStrategy(vm, RunStrategyAlways); 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 start VirtualMachine: %w", err)
+	}
+
+	return updatedVM, true, nil
+}

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

@@ -0,0 +1,94 @@
+package start
+
+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_start",
+				Description: "Start a halted or stopped VirtualMachine by changing its runStrategy to Always",
+				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 start",
+						},
+					},
+					Required: []string{"namespace", "name"},
+				},
+				Annotations: api.ToolAnnotations{
+					Title:           "Virtual Machine: Start",
+					ReadOnlyHint:    ptr.To(false),
+					DestructiveHint: ptr.To(false),
+					IdempotentHint:  ptr.To(true),
+					OpenWorldHint:   ptr.To(false),
+				},
+			},
+			Handler: start,
+		},
+	}
+}
+
+func start(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
+	}
+
+	// Start the VirtualMachine using kubevirt helper
+	dynamicClient := params.AccessControlClientset().DynamicClient()
+	vm, wasStarted, err := kubevirt.StartVM(params.Context, dynamicClient, namespace, name)
+	if err != nil {
+		return api.NewToolCallResult("", err), nil
+	}
+
+	// Generate appropriate message
+	var message string
+	if wasStarted {
+		message = "# VirtualMachine started successfully\n"
+	} else {
+		message = fmt.Sprintf("# VirtualMachine '%s' in namespace '%s' is already running\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
+}