feat: add -l/--label flag to thv run and thv list commands (#1084)

Signed-off-by: Juan Antonio Osorio <[email protected]>
Co-authored-by: Jakub Hrozek <[email protected]>

Author: JAORMX

cmd/thv/app/list.go

@@ -20,13 +20,15 @@ var listCmd = &cobra.Command{
 }
 
 var (
-	listAll    bool
-	listFormat string
+	listAll         bool
+	listFormat      string
+	listLabelFilter []string
 )
 
 func init() {
 	listCmd.Flags().BoolVarP(&listAll, "all", "a", false, "Show all workloads (default shows just running)")
 	listCmd.Flags().StringVar(&listFormat, "format", FormatText, "Output format (json, text, or mcpservers)")
+	listCmd.Flags().StringArrayVarP(&listLabelFilter, "label", "l", []string{}, "Filter workloads by labels (format: key=value)")
 }
 
 func listCmdFunc(cmd *cobra.Command, _ []string) error {
@@ -38,7 +40,7 @@ func listCmdFunc(cmd *cobra.Command, _ []string) error {
 		return fmt.Errorf("failed to create status manager: %v", err)
 	}
 
-	workloadList, err := manager.ListWorkloads(ctx, listAll)
+	workloadList, err := manager.ListWorkloads(ctx, listAll, listLabelFilter...)
 	if err != nil {
 		return fmt.Errorf("failed to list workloads: %v", err)
 	}

cmd/thv/app/run.go

@@ -91,6 +91,9 @@ var (
 
 	// Network isolation flag
 	runIsolateNetwork bool
+
+	// Labels flag
+	runLabels []string
 )
 
 func init() {
@@ -223,6 +226,13 @@ func init() {
 			"(comma-separated: ENV1,ENV2)")
 	runCmd.Flags().BoolVar(&runIsolateNetwork, "isolate-network", false,
 		"Isolate the container network from the host (default: false)")
+	runCmd.Flags().StringArrayVarP(
+		&runLabels,
+		"label",
+		"l",
+		[]string{},
+		"Set labels on the container (format: key=value)",
+	)
 
 }
 
@@ -365,6 +375,7 @@ func runCmdFunc(cmd *cobra.Command, args []string) error {
 		effectivePort,
 		runTargetPort,
 		runEnv,
+		runLabels,
 		oidcIssuer,
 		oidcAudience,
 		oidcJwksURL,

docs/cli/thv_list.md

@@ -115,3 +115,186 @@ func GetPort(labels map[string]string) (int, error) {
 func GetToolType(labels map[string]string) string {
 	return labels[LabelToolType]
 }
+
+// IsStandardToolHiveLabel checks if a label key is a standard ToolHive label
+// that should not be passed through from user input or displayed to users
+func IsStandardToolHiveLabel(key string) bool {
+	standardLabels := []string{
+		LabelToolHive,
+		LabelName,
+		LabelBaseName,
+		LabelTransport,
+		LabelPort,
+		LabelToolType,
+		LabelNetworkIsolation,
+	}
+
+	for _, standardLabel := range standardLabels {
+		if key == standardLabel {
+			return true
+		}
+	}
+
+	return false
+}
+
+// ParseLabel parses a label string in the format "key=value" and validates it
+// according to Kubernetes label naming conventions
+func ParseLabel(label string) (string, string, error) {
+	parts := strings.SplitN(label, "=", 2)
+	if len(parts) != 2 {
+		return "", "", fmt.Errorf("invalid label format, expected key=value")
+	}
+
+	key := strings.TrimSpace(parts[0])
+	value := strings.TrimSpace(parts[1])
+
+	if key == "" {
+		return "", "", fmt.Errorf("label key cannot be empty")
+	}
+
+	return key, value, nil
+}
+
+// validateLabelKey validates a label key according to Kubernetes naming conventions
+func validateLabelKey(key string) error {
+	if len(key) == 0 {
+		return fmt.Errorf("key cannot be empty")
+	}
+	if len(key) > 253 {
+		return fmt.Errorf("key cannot be longer than 253 characters")
+	}
+
+	// Check for valid prefix (optional)
+	parts := strings.Split(key, "/")
+	if len(parts) > 2 {
+		return fmt.Errorf("key can have at most one '/' separator")
+	}
+
+	var name string
+	if len(parts) == 2 {
+		prefix := parts[0]
+		name = parts[1]
+
+		// Validate prefix (should be a valid DNS subdomain)
+		if len(prefix) > 253 {
+			return fmt.Errorf("prefix cannot be longer than 253 characters")
+		}
+		if !isValidDNSSubdomain(prefix) {
+			return fmt.Errorf("prefix must be a valid DNS subdomain")
+		}
+	} else {
+		name = parts[0]
+	}
+
+	// Validate name part
+	if len(name) == 0 {
+		return fmt.Errorf("name part cannot be empty")
+	}
+	if len(name) > 63 {
+		return fmt.Errorf("name part cannot be longer than 63 characters")
+	}
+	if !isValidLabelName(name) {
+		return fmt.Errorf("name part must consist of alphanumeric characters, '-', '_' or '.', " +
+			"and must start and end with an alphanumeric character")
+	}
+
+	return nil
+}
+
+// validateLabelValue validates a label value according to Kubernetes naming conventions
+func validateLabelValue(value string) error {
+	if len(value) > 63 {
+		return fmt.Errorf("value cannot be longer than 63 characters")
+	}
+	if value != "" && !isValidLabelName(value) {
+		return fmt.Errorf("value must consist of alphanumeric characters, '-', '_' or '.', " +
+			"and must start and end with an alphanumeric character")
+	}
+	return nil
+}
+
+// isValidDNSSubdomain checks if a string is a valid DNS subdomain
+func isValidDNSSubdomain(s string) bool {
+	if len(s) == 0 || len(s) > 253 {
+		return false
+	}
+
+	parts := strings.Split(s, ".")
+	for _, part := range parts {
+		if len(part) == 0 || len(part) > 63 {
+			return false
+		}
+		if !isValidDNSLabel(part) {
+			return false
+		}
+	}
+	return true
+}
+
+// isValidDNSLabel checks if a string is a valid DNS label
+func isValidDNSLabel(s string) bool {
+	if len(s) == 0 || len(s) > 63 {
+		return false
+	}
+
+	// Must start and end with alphanumeric
+	if !isAlphaNumeric(s[0]) || !isAlphaNumeric(s[len(s)-1]) {
+		return false
+	}
+
+	// Middle characters can be alphanumeric or hyphen
+	for i := 1; i < len(s)-1; i++ {
+		if !isAlphaNumeric(s[i]) && s[i] != '-' {
+			return false
+		}
+	}
+
+	return true
+}
+
+// isValidLabelName checks if a string is a valid label name
+func isValidLabelName(s string) bool {
+	if len(s) == 0 {
+		return false
+	}
+
+	// Must start and end with alphanumeric
+	if !isAlphaNumeric(s[0]) || !isAlphaNumeric(s[len(s)-1]) {
+		return false
+	}
+
+	// Middle characters can be alphanumeric, hyphen, underscore, or dot
+	for i := 1; i < len(s)-1; i++ {
+		if !isAlphaNumeric(s[i]) && s[i] != '-' && s[i] != '_' && s[i] != '.' {
+			return false
+		}
+	}
+
+	return true
+}
+
+// isAlphaNumeric checks if a character is alphanumeric
+func isAlphaNumeric(c byte) bool {
+	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')
+}
+
+// ParseLabelWithValidation parses and validates a label according to Kubernetes naming conventions
+func ParseLabelWithValidation(label string) (string, string, error) {
+	key, value, err := ParseLabel(label)
+	if err != nil {
+		return "", "", err
+	}
+
+	// Validate key according to Kubernetes label naming conventions
+	if err := validateLabelKey(key); err != nil {
+		return "", "", fmt.Errorf("invalid label key: %v", err)
+	}
+
+	// Validate value according to Kubernetes label naming conventions
+	if err := validateLabelValue(value); err != nil {
+		return "", "", fmt.Errorf("invalid label value: %v", err)
+	}
+
+	return key, value, nil
+}