From f40ab57ed1aa331f28c57522016e62e3991753b0 Mon Sep 17 00:00:00 2001
From: Tommy-Lee Bannert <58707896+bannert1337@users.noreply.github.com>
Date: Fri, 29 Aug 2025 18:45:14 +0200
Subject: [PATCH 1/6] feat(batchops): add batch processing for adding labels to
 multiple resources

Add support for processing multiple resources in parallel when adding labels,
improving efficiency for bulk operations. Includes batch fetching, validation,
and result display with error handling. Uses configurable batch size and
goroutines for concurrent processing.
---
 internal/cmd/base/labels.go | 222 +++++++++++++++++++++++++++++++++++-
 1 file changed, 219 insertions(+), 3 deletions(-)

diff --git a/internal/cmd/base/labels.go b/internal/cmd/base/labels.go
index cee35c18..be4acc9a 100644
--- a/internal/cmd/base/labels.go
+++ b/internal/cmd/base/labels.go
@@ -4,8 +4,10 @@ import (
 	"errors"
 	"fmt"
 	"log"
+	"maps"
 	"slices"
 	"strings"
+	"sync"
 
 	"github.com/spf13/cobra"
 
@@ -15,6 +17,20 @@ import (
 	"github.com/hetznercloud/cli/internal/state"
 )
 
+// labelBatchSize is the batch size when processing multiple resources in parallel.
+const labelBatchSize = 10
+
+// BatchLabelResult represents the result of a batch label operation for a single resource.
+type BatchLabelResult struct {
+	IDOrName      string
+	Resource      interface{}
+	Success       bool
+	Error         error
+	LabelsAdded   []string
+	LabelsRemoved []string
+	AllLabelsRemoved bool
+}
+
 // LabelCmds allows defining commands for adding labels to resources.
 type LabelCmds[T any] struct {
 	ResourceNameSingular   string
@@ -48,6 +64,10 @@ type LabelCmds[T any] struct {
 
 	// Experimental is a function that will be used to mark the command as experimental.
 	Experimental func(state.State, *cobra.Command) *cobra.Command
+
+	// Batch operation support
+	FetchBatch    func(s state.State, idOrNames []string) ([]T, []error)
+	SetLabelsBatch func(s state.State, resources []T, labels map[string]string) []error
 }
 
 // AddCobraCommand creates a command that can be registered with cobra.
@@ -65,15 +85,15 @@ func (lc *LabelCmds[T]) AddCobraCommand(s state.State) *cobra.Command {
 	}
 
 	cmd := &cobra.Command{
-		Use:                   fmt.Sprintf("add-label [--overwrite] %s <label>...", positionalArguments(lc.ResourceNameSingular, lc.PositionalArgumentOverride)),
+		Use:                   fmt.Sprintf("add-label [--overwrite] %s... <label>...", positionalArguments(lc.ResourceNameSingular, lc.PositionalArgumentOverride)),
 		Short:                 lc.ShortDescriptionAdd,
 		Args:                  util.Validate,
 		ValidArgsFunction:     cmpl.SuggestArgs(suggestArgs...),
 		TraverseChildren:      true,
 		DisableFlagsInUseLine: true,
-		PreRunE:               util.ChainRunE(lc.validateAddLabel, s.EnsureToken),
+		PreRunE:               util.ChainRunE(lc.validateAddLabelBatch, s.EnsureToken),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return lc.RunAdd(s, cmd, args)
+			return lc.RunAddBatch(s, cmd, args)
 		},
 	}
 
@@ -130,6 +150,170 @@ func (lc *LabelCmds[T]) RunAdd(s state.State, cmd *cobra.Command, args []string)
 	return nil
 }
 
+// RunAddBatch executes a batch add label command
+func (lc *LabelCmds[T]) RunAddBatch(s state.State, cmd *cobra.Command, args []string) error {
+	overwrite, _ := cmd.Flags().GetBool("overwrite")
+
+	// Parse arguments to separate resources from labels
+	var resourceArgs []string
+	var labelArgs []string
+
+	// Separate arguments: those with '=' are labels, others are resources
+	for _, arg := range args {
+		if strings.Contains(arg, "=") {
+			labelArgs = append(labelArgs, arg)
+		} else {
+			resourceArgs = append(resourceArgs, arg)
+		}
+	}
+
+	if len(resourceArgs) == 0 {
+		return fmt.Errorf("must specify at least one %s", strings.ToLower(lc.ResourceNameSingular))
+	}
+
+	if len(labelArgs) == 0 {
+		return fmt.Errorf("must specify at least one label")
+	}
+
+	// Parse labels to add
+	labelsToAdd := make(map[string]string)
+	var labelKeys []string
+	for _, label := range labelArgs {
+		key, val := util.SplitLabelVars(label)
+		labelsToAdd[key] = val
+		labelKeys = append(labelKeys, key)
+	}
+
+	// Process resources in batches
+	errs := make([]error, 0, len(resourceArgs))
+	results := make([]BatchLabelResult, 0, len(resourceArgs))
+
+	for batch := range slices.Chunk(resourceArgs, labelBatchSize) {
+		batchResults := lc.processAddBatch(s, batch, labelsToAdd, overwrite)
+		results = append(results, batchResults...)
+
+		// Collect errors
+		for _, result := range batchResults {
+			if result.Error != nil {
+				errs = append(errs, result.Error)
+			}
+		}
+	}
+
+	// Display results
+	lc.displayAddResults(cmd, results, labelKeys)
+
+	return errors.Join(errs...)
+}
+
+// processAddBatch processes a batch of resources for adding labels
+func (lc *LabelCmds[T]) processAddBatch(s state.State, idOrNames []string, labelsToAdd map[string]string, overwrite bool) []BatchLabelResult {
+	results := make([]BatchLabelResult, len(idOrNames))
+
+	// Fetch all resources in batch
+	resources, fetchErrors := lc.fetchResourcesBatch(s, idOrNames)
+
+	for i, idOrName := range idOrNames {
+		results[i] = BatchLabelResult{IDOrName: idOrName}
+
+		if fetchErrors[i] != nil {
+			results[i].Error = fetchErrors[i]
+			continue
+		}
+
+		resource := resources[i]
+		if util.IsNil(resource) {
+			results[i].Error = fmt.Errorf("%s not found: %s", lc.ResourceNameSingular, idOrName)
+			continue
+		}
+
+		// Get current labels
+		existingLabels := lc.GetLabels(resource)
+		if existingLabels == nil {
+			existingLabels = make(map[string]string)
+		}
+
+		// Check for conflicts
+		var conflictKeys []string
+		for key := range labelsToAdd {
+			if _, exists := existingLabels[key]; exists && !overwrite {
+				conflictKeys = append(conflictKeys, key)
+			}
+		}
+
+		if len(conflictKeys) > 0 {
+			results[i].Error = fmt.Errorf("label(s) %s on %s %s already exist",
+				strings.Join(conflictKeys, ", "), lc.ResourceNameSingular, idOrName)
+			continue
+		}
+
+		// Merge new labels
+		for key, value := range labelsToAdd {
+			existingLabels[key] = value
+		}
+
+		// Apply labels
+		if err := lc.SetLabels(s, resource, existingLabels); err != nil {
+			results[i].Error = err
+			continue
+		}
+
+		results[i].Success = true
+		results[i].Resource = resource
+		results[i].LabelsAdded = slices.Collect(maps.Keys(labelsToAdd))
+	}
+
+	return results
+}
+
+// fetchResourcesBatch fetches multiple resources in parallel
+func (lc *LabelCmds[T]) fetchResourcesBatch(s state.State, idOrNames []string) ([]T, []error) {
+	if lc.FetchBatch != nil {
+		return lc.FetchBatch(s, idOrNames)
+	}
+
+	// Fallback to individual fetching with goroutines
+	resources := make([]T, len(idOrNames))
+	errors := make([]error, len(idOrNames))
+
+	var wg sync.WaitGroup
+	for i, idOrName := range idOrNames {
+		wg.Add(1)
+		go func(idx int, id string) {
+			defer wg.Done()
+			resource, err := lc.Fetch(s, id)
+			resources[idx] = resource
+			errors[idx] = err
+		}(i, idOrName)
+	}
+	wg.Wait()
+
+	return resources, errors
+}
+
+// displayAddResults displays the results of a batch add operation
+func (lc *LabelCmds[T]) displayAddResults(cmd *cobra.Command, results []BatchLabelResult, labelKeys []string) {
+	successful := 0
+	failed := 0
+
+	for _, result := range results {
+		if result.Success {
+			successful++
+			cmd.Printf("✓ %s: Labels %s added\n",
+				result.IDOrName,
+				strings.Join(labelKeys, ", "))
+		} else {
+			failed++
+			cmd.Printf("✗ %s: %v\n", result.IDOrName, result.Error)
+		}
+	}
+
+	// Summary for multiple resources
+	if len(results) > 1 {
+		cmd.Printf("\nSummary: %d successful, %d failed\n", successful, failed)
+	}
+}
+
 func (lc *LabelCmds[T]) validateAddLabel(_ *cobra.Command, args []string) error {
 	numPosArgs := max(1, len(lc.PositionalArgumentOverride))
 
@@ -142,6 +326,38 @@ func (lc *LabelCmds[T]) validateAddLabel(_ *cobra.Command, args []string) error
 	return nil
 }
 
+// validateAddLabelBatch validates arguments for batch add label operations
+func (lc *LabelCmds[T]) validateAddLabelBatch(_ *cobra.Command, args []string) error {
+	var resourceArgs []string
+	var labelArgs []string
+
+	// Separate arguments: those with '=' are labels, others are resources
+	for _, arg := range args {
+		if strings.Contains(arg, "=") {
+			labelArgs = append(labelArgs, arg)
+		} else {
+			resourceArgs = append(resourceArgs, arg)
+		}
+	}
+
+	if len(resourceArgs) == 0 {
+		return fmt.Errorf("must specify at least one %s", strings.ToLower(lc.ResourceNameSingular))
+	}
+
+	if len(labelArgs) == 0 {
+		return fmt.Errorf("must specify at least one label")
+	}
+
+	// Validate label format for all labels
+	for _, label := range labelArgs {
+		if len(util.SplitLabel(label)) != 2 {
+			return fmt.Errorf("invalid label: %s", label)
+		}
+	}
+
+	return nil
+}
+
 // RemoveCobraCommand creates a command that can be registered with cobra.
 func (lc *LabelCmds[T]) RemoveCobraCommand(s state.State) *cobra.Command {
 	var suggestArgs []cobra.CompletionFunc

From 2b7cc8bbe9f2b851831b83f72eea8604a2550bf5 Mon Sep 17 00:00:00 2001
From: Tommy-Lee Bannert <58707896+bannert1337@users.noreply.github.com>
Date: Fri, 29 Aug 2025 18:45:32 +0200
Subject: [PATCH 2/6] feat(batchops): add batch processing for load balancer
 labels

Implement FetchBatch and SetLabelsBatch functions to enable concurrent fetching and updating of labels for multiple load balancers using goroutines, improving performance for bulk operations. This extends the existing label command functionality to support batch processing.
---
 internal/cmd/loadbalancer/labels.go | 52 ++++++++++++++++++++++++++++-
 1 file changed, 51 insertions(+), 1 deletion(-)

diff --git a/internal/cmd/loadbalancer/labels.go b/internal/cmd/loadbalancer/labels.go
index 6c5f8e50..728074bc 100644
--- a/internal/cmd/loadbalancer/labels.go
+++ b/internal/cmd/loadbalancer/labels.go
@@ -3,11 +3,13 @@ package loadbalancer
 import (
 	"fmt"
 	"strconv"
+	"sync"
+
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 
 	"github.com/hetznercloud/cli/internal/cmd/base"
 	"github.com/hetznercloud/cli/internal/hcapi2"
 	"github.com/hetznercloud/cli/internal/state"
-	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 )
 
 var LabelCmds = base.LabelCmds[*hcloud.LoadBalancer]{
@@ -39,4 +41,52 @@ var LabelCmds = base.LabelCmds[*hcloud.LoadBalancer]{
 	GetIDOrName: func(loadBalancer *hcloud.LoadBalancer) string {
 		return strconv.FormatInt(loadBalancer.ID, 10)
 	},
+	FetchBatch: func(s state.State, idOrNames []string) ([]*hcloud.LoadBalancer, []error) {
+		loadBalancers := make([]*hcloud.LoadBalancer, len(idOrNames))
+		errors := make([]error, len(idOrNames))
+
+		var wg sync.WaitGroup
+		for i, idOrName := range idOrNames {
+			wg.Add(1)
+			go func(idx int, id string) {
+				defer wg.Done()
+				loadBalancer, _, err := s.Client().LoadBalancer().Get(s, id)
+				if err != nil {
+					errors[idx] = err
+					return
+				}
+				if loadBalancer == nil {
+					errors[idx] = fmt.Errorf("Load Balancer not found: %s", id)
+					return
+				}
+				loadBalancers[idx] = loadBalancer
+			}(i, idOrName)
+		}
+		wg.Wait()
+
+		return loadBalancers, errors
+	},
+	SetLabelsBatch: func(s state.State, loadBalancers []*hcloud.LoadBalancer, labels map[string]string) []error {
+		errors := make([]error, len(loadBalancers))
+
+		var wg sync.WaitGroup
+		for i, loadBalancer := range loadBalancers {
+			if loadBalancer == nil {
+				continue
+			}
+
+			wg.Add(1)
+			go func(idx int, lb *hcloud.LoadBalancer) {
+				defer wg.Done()
+				opts := hcloud.LoadBalancerUpdateOpts{
+					Labels: labels,
+				}
+				_, _, err := s.Client().LoadBalancer().Update(s, lb, opts)
+				errors[idx] = err
+			}(i, loadBalancer)
+		}
+		wg.Wait()
+
+		return errors
+	},
 }

From 24703aa074f04c0a4e89e69ead8f9319367e49aa Mon Sep 17 00:00:00 2001
From: Tommy-Lee Bannert <58707896+bannert1337@users.noreply.github.com>
Date: Fri, 29 Aug 2025 18:45:43 +0200
Subject: [PATCH 3/6] feat(batchops): add batch processing for network labels

---
 internal/cmd/network/labels.go | 52 +++++++++++++++++++++++++++++++++-
 1 file changed, 51 insertions(+), 1 deletion(-)

diff --git a/internal/cmd/network/labels.go b/internal/cmd/network/labels.go
index 1e4888a3..0df609c1 100644
--- a/internal/cmd/network/labels.go
+++ b/internal/cmd/network/labels.go
@@ -3,11 +3,13 @@ package network
 import (
 	"fmt"
 	"strconv"
+	"sync"
+
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 
 	"github.com/hetznercloud/cli/internal/cmd/base"
 	"github.com/hetznercloud/cli/internal/hcapi2"
 	"github.com/hetznercloud/cli/internal/state"
-	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 )
 
 var LabelCmds = base.LabelCmds[*hcloud.Network]{
@@ -39,4 +41,52 @@ var LabelCmds = base.LabelCmds[*hcloud.Network]{
 	GetIDOrName: func(network *hcloud.Network) string {
 		return strconv.FormatInt(network.ID, 10)
 	},
+	FetchBatch: func(s state.State, idOrNames []string) ([]*hcloud.Network, []error) {
+		networks := make([]*hcloud.Network, len(idOrNames))
+		errors := make([]error, len(idOrNames))
+
+		var wg sync.WaitGroup
+		for i, idOrName := range idOrNames {
+			wg.Add(1)
+			go func(idx int, id string) {
+				defer wg.Done()
+				network, _, err := s.Client().Network().Get(s, id)
+				if err != nil {
+					errors[idx] = err
+					return
+				}
+				if network == nil {
+					errors[idx] = fmt.Errorf("Network not found: %s", id)
+					return
+				}
+				networks[idx] = network
+			}(i, idOrName)
+		}
+		wg.Wait()
+
+		return networks, errors
+	},
+	SetLabelsBatch: func(s state.State, networks []*hcloud.Network, labels map[string]string) []error {
+		errors := make([]error, len(networks))
+
+		var wg sync.WaitGroup
+		for i, network := range networks {
+			if network == nil {
+				continue
+			}
+
+			wg.Add(1)
+			go func(idx int, net *hcloud.Network) {
+				defer wg.Done()
+				opts := hcloud.NetworkUpdateOpts{
+					Labels: labels,
+				}
+				_, _, err := s.Client().Network().Update(s, net, opts)
+				errors[idx] = err
+			}(i, network)
+		}
+		wg.Wait()
+
+		return errors
+	},
 }

From b635357b849283a77aaf5afd33d89a7608fa571d Mon Sep 17 00:00:00 2001
From: Tommy-Lee Bannert <58707896+bannert1337@users.noreply.github.com>
Date: Fri, 29 Aug 2025 18:45:51 +0200
Subject: [PATCH 4/6] feat(batchops): add batch processing for volume labels

---
 internal/cmd/volume/labels.go | 52 ++++++++++++++++++++++++++++++++++-
 1 file changed, 51 insertions(+), 1 deletion(-)

diff --git a/internal/cmd/volume/labels.go b/internal/cmd/volume/labels.go
index ca16cbd7..dd4619b1 100644
--- a/internal/cmd/volume/labels.go
+++ b/internal/cmd/volume/labels.go
@@ -3,11 +3,13 @@ package volume
 import (
 	"fmt"
 	"strconv"
+	"sync"
+
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 
 	"github.com/hetznercloud/cli/internal/cmd/base"
 	"github.com/hetznercloud/cli/internal/hcapi2"
 	"github.com/hetznercloud/cli/internal/state"
-	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 )
 
 var LabelCmds = base.LabelCmds[*hcloud.Volume]{
@@ -39,4 +41,52 @@ var LabelCmds = base.LabelCmds[*hcloud.Volume]{
 	GetIDOrName: func(volume *hcloud.Volume) string {
 		return strconv.FormatInt(volume.ID, 10)
 	},
+	FetchBatch: func(s state.State, idOrNames []string) ([]*hcloud.Volume, []error) {
+		volumes := make([]*hcloud.Volume, len(idOrNames))
+		errors := make([]error, len(idOrNames))
+
+		var wg sync.WaitGroup
+		for i, idOrName := range idOrNames {
+			wg.Add(1)
+			go func(idx int, id string) {
+				defer wg.Done()
+				volume, _, err := s.Client().Volume().Get(s, id)
+				if err != nil {
+					errors[idx] = err
+					return
+				}
+				if volume == nil {
+					errors[idx] = fmt.Errorf("Volume not found: %s", id)
+					return
+				}
+				volumes[idx] = volume
+			}(i, idOrName)
+		}
+		wg.Wait()
+
+		return volumes, errors
+	},
+	SetLabelsBatch: func(s state.State, volumes []*hcloud.Volume, labels map[string]string) []error {
+		errors := make([]error, len(volumes))
+
+		var wg sync.WaitGroup
+		for i, volume := range volumes {
+			if volume == nil {
+				continue
+			}
+
+			wg.Add(1)
+			go func(idx int, vol *hcloud.Volume) {
+				defer wg.Done()
+				opts := hcloud.VolumeUpdateOpts{
+					Labels: labels,
+				}
+				_, _, err := s.Client().Volume().Update(s, vol, opts)
+				errors[idx] = err
+			}(i, volume)
+		}
+		wg.Wait()
+
+		return errors
+	},
 }

From 92b1147a891e7a92aaa8ba6569b612818caa5131 Mon Sep 17 00:00:00 2001
From: Tommy-Lee Bannert <58707896+bannert1337@users.noreply.github.com>
Date: Fri, 29 Aug 2025 18:46:13 +0200
Subject: [PATCH 5/6] feat(batchops): add batch processing for server labels

Add FetchBatch and SetLabelsBatch functions to the server label commands, enabling concurrent batch operations for fetching and updating labels on multiple servers using goroutines for improved performance.
---
 internal/cmd/server/labels.go | 52 ++++++++++++++++++++++++++++++++++-
 1 file changed, 51 insertions(+), 1 deletion(-)

diff --git a/internal/cmd/server/labels.go b/internal/cmd/server/labels.go
index bd47213f..a03606d2 100644
--- a/internal/cmd/server/labels.go
+++ b/internal/cmd/server/labels.go
@@ -3,11 +3,13 @@ package server
 import (
 	"fmt"
 	"strconv"
+	"sync"
+
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 
 	"github.com/hetznercloud/cli/internal/cmd/base"
 	"github.com/hetznercloud/cli/internal/hcapi2"
 	state "github.com/hetznercloud/cli/internal/state"
-	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 )
 
 var LabelCmds = base.LabelCmds[*hcloud.Server]{
@@ -39,4 +41,52 @@ var LabelCmds = base.LabelCmds[*hcloud.Server]{
 	GetIDOrName: func(server *hcloud.Server) string {
 		return strconv.FormatInt(server.ID, 10)
 	},
+	FetchBatch: func(s state.State, idOrNames []string) ([]*hcloud.Server, []error) {
+		servers := make([]*hcloud.Server, len(idOrNames))
+		errors := make([]error, len(idOrNames))
+
+		var wg sync.WaitGroup
+		for i, idOrName := range idOrNames {
+			wg.Add(1)
+			go func(idx int, id string) {
+				defer wg.Done()
+				server, _, err := s.Client().Server().Get(s, id)
+				if err != nil {
+					errors[idx] = err
+					return
+				}
+				if server == nil {
+					errors[idx] = fmt.Errorf("Server not found: %s", id)
+					return
+				}
+				servers[idx] = server
+			}(i, idOrName)
+		}
+		wg.Wait()
+
+		return servers, errors
+	},
+	SetLabelsBatch: func(s state.State, servers []*hcloud.Server, labels map[string]string) []error {
+		errors := make([]error, len(servers))
+
+		var wg sync.WaitGroup
+		for i, server := range servers {
+			if server == nil {
+				continue
+			}
+
+			wg.Add(1)
+			go func(idx int, srv *hcloud.Server) {
+				defer wg.Done()
+				opts := hcloud.ServerUpdateOpts{
+					Labels: labels,
+				}
+				_, _, err := s.Client().Server().Update(s, srv, opts)
+				errors[idx] = err
+			}(i, server)
+		}
+		wg.Wait()
+
+		return errors
+	},
 }

From 7b4f69c74b9c14619ff363a68e3b5afe7fe5bed1 Mon Sep 17 00:00:00 2001
From: Tommy-Lee Bannert <58707896+bannert1337@users.noreply.github.com>
Date: Fri, 29 Aug 2025 18:51:37 +0200
Subject: [PATCH 6/6] test(batchops): add comprehensive tests for batch label
 operations

---
 internal/cmd/base/labels_test.go | 466 +++++++++++++++++++++++++++++++
 1 file changed, 466 insertions(+)
 create mode 100644 internal/cmd/base/labels_test.go

diff --git a/internal/cmd/base/labels_test.go b/internal/cmd/base/labels_test.go
new file mode 100644
index 00000000..f460da2b
--- /dev/null
+++ b/internal/cmd/base/labels_test.go
@@ -0,0 +1,466 @@
+package base
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+
+	"github.com/hetznercloud/hcloud-go/v2/hcloud"
+
+	"github.com/hetznercloud/cli/internal/state"
+)
+
+// MockResource represents a mock resource for testing
+type MockResource struct {
+	ID     int64
+	Name   string
+	Labels map[string]string
+}
+
+// MockLabelCmds creates a mock LabelCmds for testing
+func createMockLabelCmds() *LabelCmds[*MockResource] {
+	return &LabelCmds[*MockResource]{
+		ResourceNameSingular: "Mock Resource",
+		ShortDescriptionAdd:  "Add a label to a Mock Resource",
+		Fetch: func(s state.State, idOrName string) (*MockResource, error) {
+			// Mock implementation - return a resource if name starts with "mock"
+			if strings.HasPrefix(idOrName, "mock") {
+				return &MockResource{
+					ID:     1,
+					Name:   idOrName,
+					Labels: make(map[string]string),
+				}, nil
+			}
+			return nil, &hcloud.Error{Code: hcloud.ErrorCodeNotFound}
+		},
+		SetLabels: func(s state.State, resource *MockResource, labels map[string]string) error {
+			resource.Labels = labels
+			return nil
+		},
+		GetLabels: func(resource *MockResource) map[string]string {
+			return resource.Labels
+		},
+		GetIDOrName: func(resource *MockResource) string {
+			return resource.Name
+		},
+		FetchBatch: func(s state.State, idOrNames []string) ([]*MockResource, []error) {
+			resources := make([]*MockResource, len(idOrNames))
+			errors := make([]error, len(idOrNames))
+
+			for i, idOrName := range idOrNames {
+				if strings.HasPrefix(idOrName, "mock") {
+					resources[i] = &MockResource{
+						ID:     int64(i + 1),
+						Name:   idOrName,
+						Labels: make(map[string]string),
+					}
+				} else {
+					errors[i] = &hcloud.Error{Code: hcloud.ErrorCodeNotFound}
+				}
+			}
+
+			return resources, errors
+		},
+		SetLabelsBatch: func(s state.State, resources []*MockResource, labels map[string]string) []error {
+			errors := make([]error, len(resources))
+			for _, resource := range resources {
+				if resource != nil {
+					resource.Labels = labels
+				}
+			}
+			return errors
+		},
+	}
+}
+
+func TestLabelCmds_RunAddBatch_Success(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	// Mock state (we won't use it in this test)
+	var mockState state.State
+
+	// Mock command
+	cmd := &cobra.Command{}
+
+	// Test successful batch operation
+	args := []string{"mock1", "mock2", "env=prod", "team=backend"}
+	err := cmds.RunAddBatch(mockState, cmd, args)
+
+	// Should not return an error for successful operations
+	if err != nil {
+		t.Errorf("Expected no error, got: %v", err)
+	}
+}
+
+func TestLabelCmds_RunAddBatch_PartialFailure(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	// Mock state
+	var mockState state.State
+
+	// Mock command
+	cmd := &cobra.Command{}
+
+	// Test partial failure (some resources exist, some don't)
+	args := []string{"mock1", "nonexistent", "mock2", "env=prod"}
+	err := cmds.RunAddBatch(mockState, cmd, args)
+
+	// Should return an error due to partial failure
+	if err == nil {
+		t.Error("Expected error due to partial failure, got nil")
+	}
+
+	// Check that error contains information about failures
+	if !strings.Contains(err.Error(), "not_found") {
+		t.Errorf("Expected error to contain 'not_found', got: %v", err)
+	}
+}
+
+func TestLabelCmds_RunAddBatch_NoResources(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	var mockState state.State
+	cmd := &cobra.Command{}
+
+	// Test with no resources
+	args := []string{"env=prod"}
+	err := cmds.RunAddBatch(mockState, cmd, args)
+
+	if err == nil {
+		t.Error("Expected error for no resources, got nil")
+	}
+
+	if !strings.Contains(err.Error(), "must specify at least one") {
+		t.Errorf("Expected error to contain 'must specify at least one', got: %v", err)
+	}
+}
+
+func TestLabelCmds_RunAddBatch_NoLabels(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	var mockState state.State
+	cmd := &cobra.Command{}
+
+	// Test with no labels
+	args := []string{"mock1", "mock2"}
+	err := cmds.RunAddBatch(mockState, cmd, args)
+
+	if err == nil {
+		t.Error("Expected error for no labels, got nil")
+	}
+
+	if !strings.Contains(err.Error(), "must specify at least one label") {
+		t.Errorf("Expected error to contain 'must specify at least one label', got: %v", err)
+	}
+}
+
+func TestLabelCmds_RunAddBatch_InvalidLabelFormat(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	var mockState state.State
+	cmd := &cobra.Command{}
+
+	// Test with invalid label format
+	args := []string{"mock1", "invalid-label"}
+	err := cmds.RunAddBatch(mockState, cmd, args)
+
+	if err == nil {
+		t.Error("Expected error for invalid label format, got nil")
+	}
+
+	if !strings.Contains(err.Error(), "must specify at least one label") {
+		t.Errorf("Expected error to contain 'must specify at least one label', got: %v", err)
+	}
+}
+
+func TestLabelCmds_validateAddLabelBatch_Success(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	cmd := &cobra.Command{}
+	args := []string{"mock1", "mock2", "env=prod", "team=backend"}
+
+	err := cmds.validateAddLabelBatch(cmd, args)
+
+	if err != nil {
+		t.Errorf("Expected no validation error, got: %v", err)
+	}
+}
+
+func TestLabelCmds_validateAddLabelBatch_NoResources(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	cmd := &cobra.Command{}
+	args := []string{"env=prod", "team=backend"}
+
+	err := cmds.validateAddLabelBatch(cmd, args)
+
+	if err == nil {
+		t.Error("Expected validation error for no resources, got nil")
+	}
+
+	if !strings.Contains(err.Error(), "must specify at least one mock resource") {
+		t.Errorf("Expected error to contain 'must specify at least one mock resource', got: %v", err)
+	}
+}
+
+func TestLabelCmds_validateAddLabelBatch_NoLabels(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	cmd := &cobra.Command{}
+	args := []string{"mock1", "mock2"}
+
+	err := cmds.validateAddLabelBatch(cmd, args)
+
+	if err == nil {
+		t.Error("Expected validation error for no labels, got nil")
+	}
+
+	if !strings.Contains(err.Error(), "must specify at least one label") {
+		t.Errorf("Expected error to contain 'must specify at least one label', got: %v", err)
+	}
+}
+
+func TestLabelCmds_validateAddLabelBatch_InvalidLabel(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	cmd := &cobra.Command{}
+	args := []string{"mock1", "invalid-label-format"}
+
+	err := cmds.validateAddLabelBatch(cmd, args)
+
+	if err == nil {
+		t.Error("Expected validation error for invalid label, got nil")
+	}
+
+	if !strings.Contains(err.Error(), "must specify at least one label") {
+		t.Errorf("Expected error to contain 'must specify at least one label', got: %v", err)
+	}
+}
+
+func TestLabelCmds_validateAddLabelBatch_MixedOrder(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	cmd := &cobra.Command{}
+	// Test mixed order of resources and labels
+	args := []string{"env=prod", "mock1", "team=backend", "mock2"}
+
+	err := cmds.validateAddLabelBatch(cmd, args)
+
+	if err != nil {
+		t.Errorf("Expected no validation error for mixed order, got: %v", err)
+	}
+}
+
+func TestLabelCmds_processAddBatch_Success(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	var mockState state.State
+	idOrNames := []string{"mock1", "mock2"}
+	labelsToAdd := map[string]string{
+		"env":  "prod",
+		"team": "backend",
+	}
+
+	results := cmds.processAddBatch(mockState, idOrNames, labelsToAdd, false)
+
+	if len(results) != 2 {
+		t.Errorf("Expected 2 results, got %d", len(results))
+	}
+
+	for i, result := range results {
+		if !result.Success {
+			t.Errorf("Expected result %d to be successful, got error: %v", i, result.Error)
+		}
+		if result.IDOrName != idOrNames[i] {
+			t.Errorf("Expected IDOrName %s, got %s", idOrNames[i], result.IDOrName)
+		}
+	}
+}
+
+func TestLabelCmds_processAddBatch_ResourceNotFound(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	var mockState state.State
+	idOrNames := []string{"mock1", "nonexistent"}
+	labelsToAdd := map[string]string{"env": "prod"}
+
+	results := cmds.processAddBatch(mockState, idOrNames, labelsToAdd, false)
+
+	if len(results) != 2 {
+		t.Errorf("Expected 2 results, got %d", len(results))
+	}
+
+	// First result should be successful
+	if !results[0].Success {
+		t.Errorf("Expected first result to be successful, got error: %v", results[0].Error)
+	}
+
+	// Second result should fail
+	if results[1].Success {
+		t.Error("Expected second result to fail, but it was successful")
+	}
+
+	if results[1].Error == nil {
+		t.Error("Expected second result to have an error, but it was nil")
+	}
+}
+
+func TestLabelCmds_displayAddResults(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	cmd := &cobra.Command{}
+	results := []BatchLabelResult{
+		{IDOrName: "mock1", Success: true, LabelsAdded: []string{"env", "team"}},
+		{IDOrName: "mock2", Success: true, LabelsAdded: []string{"env", "team"}},
+	}
+	labelKeys := []string{"env", "team"}
+
+	// Capture output by redirecting cmd's output
+	// This is a simplified test - in a real scenario you'd capture the output
+	cmds.displayAddResults(cmd, results, labelKeys)
+
+	// Test with failures
+	resultsWithFailures := []BatchLabelResult{
+		{IDOrName: "mock1", Success: true, LabelsAdded: []string{"env"}},
+		{IDOrName: "nonexistent", Success: false, Error: &hcloud.Error{Code: hcloud.ErrorCodeNotFound}},
+	}
+
+	cmds.displayAddResults(cmd, resultsWithFailures, []string{"env"})
+}
+
+func TestLabelCmds_fetchResourcesBatch_Success(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	var mockState state.State
+	idOrNames := []string{"mock1", "mock2"}
+
+	resources, errors := cmds.fetchResourcesBatch(mockState, idOrNames)
+
+	if len(resources) != 2 {
+		t.Errorf("Expected 2 resources, got %d", len(resources))
+	}
+
+	if len(errors) != 2 {
+		t.Errorf("Expected 2 errors, got %d", len(errors))
+	}
+
+	for i, resource := range resources {
+		if resource == nil {
+			t.Errorf("Expected resource at index %d to not be nil", i)
+		}
+		if errors[i] != nil {
+			t.Errorf("Expected no error at index %d, got: %v", i, errors[i])
+		}
+	}
+}
+
+func TestLabelCmds_fetchResourcesBatch_WithErrors(t *testing.T) {
+	cmds := createMockLabelCmds()
+
+	var mockState state.State
+	idOrNames := []string{"mock1", "nonexistent", "mock2"}
+
+	resources, errors := cmds.fetchResourcesBatch(mockState, idOrNames)
+
+	if len(resources) != 3 {
+		t.Errorf("Expected 3 resources, got %d", len(resources))
+	}
+
+	if len(errors) != 3 {
+		t.Errorf("Expected 3 errors, got %d", len(errors))
+	}
+
+	// Check first resource (should succeed)
+	if resources[0] == nil {
+		t.Error("Expected first resource to not be nil")
+	}
+	if errors[0] != nil {
+		t.Errorf("Expected no error for first resource, got: %v", errors[0])
+	}
+
+	// Check second resource (should fail)
+	if resources[1] != nil {
+		t.Error("Expected second resource to be nil due to error")
+	}
+	if errors[1] == nil {
+		t.Error("Expected error for second resource, got nil")
+	}
+
+	// Check third resource (should succeed)
+	if resources[2] == nil {
+		t.Error("Expected third resource to not be nil")
+	}
+	if errors[2] != nil {
+		t.Errorf("Expected no error for third resource, got: %v", errors[2])
+	}
+}
+
+func TestBatchLabelResult_Structure(t *testing.T) {
+	result := BatchLabelResult{
+		IDOrName:         "test-resource",
+		Resource:         &MockResource{ID: 1, Name: "test"},
+		Success:          true,
+		Error:            nil,
+		LabelsAdded:      []string{"env", "team"},
+		LabelsRemoved:    []string{},
+		AllLabelsRemoved: false,
+	}
+
+	if result.IDOrName != "test-resource" {
+		t.Errorf("Expected IDOrName 'test-resource', got '%s'", result.IDOrName)
+	}
+
+	if !result.Success {
+		t.Error("Expected Success to be true")
+	}
+
+	if result.Error != nil {
+		t.Errorf("Expected Error to be nil, got: %v", result.Error)
+	}
+
+	if len(result.LabelsAdded) != 2 {
+		t.Errorf("Expected 2 labels added, got %d", len(result.LabelsAdded))
+	}
+}
+
+func TestLabelBatchSize_Constant(t *testing.T) {
+	if labelBatchSize != 10 {
+		t.Errorf("Expected labelBatchSize to be 10, got %d", labelBatchSize)
+	}
+}
+
+// Benchmark tests for performance validation
+func BenchmarkLabelCmds_RunAddBatch(b *testing.B) {
+	cmds := createMockLabelCmds()
+	var mockState state.State
+	cmd := &cobra.Command{}
+
+	// Create a larger batch for benchmarking
+	args := make([]string, 0, 20)
+	for i := 0; i < 10; i++ {
+		args = append(args, "mock"+string(rune(i+'0')))
+	}
+	args = append(args, "env=prod", "team=backend")
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		cmds.RunAddBatch(mockState, cmd, args)
+	}
+}
+
+func BenchmarkLabelCmds_processAddBatch(b *testing.B) {
+	cmds := createMockLabelCmds()
+	var mockState state.State
+
+	idOrNames := make([]string, 10)
+	for i := 0; i < 10; i++ {
+		idOrNames[i] = "mock" + string(rune(i+'0'))
+	}
+	labelsToAdd := map[string]string{"env": "prod", "team": "backend"}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		cmds.processAddBatch(mockState, idOrNames, labelsToAdd, false)
+	}
+}