HYPERFLEET-864 - fix: handle string manifests in resolveGVK for discovery

resolveGVK returned empty GVK for string manifests (from ref files),
causing discovery to fail with 'Object Kind is missing'. Now extracts
apiVersion and kind by line scanning, which handles manifests with
Go template directives that break full YAML parsing.

Author: xueli181114

internal/configloader/validator.go

@@ -370,8 +370,11 @@ func (v *TaskConfigValidator) validateTemplateVariables() {
 	// Validate resource manifests and transport config templates
 	for i, resource := range v.config.Resources {
 		resourcePath := fmt.Sprintf("%s[%d]", FieldResources, i)
-		if manifest, ok := resource.Manifest.(map[string]interface{}); ok {
+		switch manifest := resource.Manifest.(type) {
+		case map[string]interface{}:
 			v.validateTemplateMap(manifest, resourcePath+"."+FieldManifest)
+		case string:
+			v.validateTemplateString(manifest, resourcePath+"."+FieldManifest)
 		}
 		// NOTE: For maestro transport, we skip template variable validation for manifest content.
 		// ManifestWork templates may use variables provided at runtime by the framework

internal/configloader/validator_test.go

@@ -354,6 +354,11 @@ func TestValidateK8sManifests(t *testing.T) {
 		// String manifests contain raw Go templates that can't be validated
 		// until template rendering at execution time
 		cfg := baseTaskConfig()
+		cfg.Params = []Parameter{
+			{Name: "name", Source: "event.name", Type: "string"},
+			{Name: "addLabels", Source: "event.addLabels", Type: "bool"},
+			{Name: "appName", Source: "event.appName", Type: "string"},
+		}
 		cfg.Resources = []Resource{{
 			Name: "testResource",
 			Manifest: `apiVersion: v1

internal/executor/resource_executor.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"strings"
 
 	"github.com/mitchellh/copystructure"
 	"github.com/openshift-hyperfleet/hyperfleet-adapter/internal/configloader"
@@ -261,6 +262,10 @@ func (re *ResourceExecutor) renderStringManifest(
 	manifestStr string,
 	params map[string]interface{},
 ) ([]byte, error) {
+	if strings.TrimSpace(manifestStr) == "" {
+		return nil, fmt.Errorf("empty manifest: string manifest cannot be empty")
+	}
+
 	// Render the entire string as a Go template
 	rendered, err := renderTemplate(manifestStr, params)
 	if err != nil {
@@ -269,8 +274,8 @@ func (re *ResourceExecutor) renderStringManifest(
 
 	// Parse the rendered string as YAML
 	var manifestData map[string]interface{}
-	if err := yaml.Unmarshal([]byte(rendered), &manifestData); err != nil {
-		return nil, fmt.Errorf("failed to parse rendered manifest as YAML: %w", err)
+	if unmarshalErr := yaml.Unmarshal([]byte(rendered), &manifestData); unmarshalErr != nil {
+		return nil, fmt.Errorf("failed to parse rendered manifest as YAML: %w", unmarshalErr)
 	}
 
 	// Marshal to JSON bytes
@@ -451,10 +456,20 @@ func (re *ResourceExecutor) buildNestedDiscoveryConfig(
 // resolveGVK extracts the GVK from the resource's manifest.
 // Works for both K8s resources and ManifestWorks since both have apiVersion and kind.
 func (re *ResourceExecutor) resolveGVK(resource configloader.Resource) schema.GroupVersionKind {
-	manifestData, ok := resource.Manifest.(map[string]interface{})
-	if !ok {
+	var manifestData map[string]interface{}
+
+	switch m := resource.Manifest.(type) {
+	case map[string]interface{}:
+		manifestData = m
+	case string:
+		// String manifests may contain Go template directives ({{ if }}, {{ range }})
+		// that make them invalid YAML. Extract apiVersion and kind by scanning lines
+		// instead of full YAML parsing.
+		return extractGVKFromString(m)
+	default:
 		return schema.GroupVersionKind{}
 	}
+
 	apiVersion, ok1 := manifestData["apiVersion"].(string)
 	kind, ok2 := manifestData["kind"].(string)
 	if !ok1 || !ok2 {
@@ -467,6 +482,34 @@ func (re *ResourceExecutor) resolveGVK(resource configloader.Resource) schema.Gr
 	return gv.WithKind(kind)
 }
 
+// extractGVKFromString extracts apiVersion and kind from a YAML string
+// by scanning lines. This handles manifests with Go template directives
+// that would fail full YAML parsing.
+func extractGVKFromString(manifest string) schema.GroupVersionKind {
+	var apiVersion, kind string
+	for _, line := range strings.Split(manifest, "\n") {
+		trimmed := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmed, "apiVersion:") {
+			apiVersion = strings.TrimSpace(strings.TrimPrefix(trimmed, "apiVersion:"))
+			apiVersion = strings.Trim(apiVersion, "\"'")
+		} else if strings.HasPrefix(trimmed, "kind:") {
+			kind = strings.TrimSpace(strings.TrimPrefix(trimmed, "kind:"))
+			kind = strings.Trim(kind, "\"'")
+		}
+		if apiVersion != "" && kind != "" {
+			break
+		}
+	}
+	if apiVersion == "" || kind == "" {
+		return schema.GroupVersionKind{}
+	}
+	gv, err := schema.ParseGroupVersion(apiVersion)
+	if err != nil {
+		return schema.GroupVersionKind{}
+	}
+	return gv.WithKind(kind)
+}
+
 // convertToStringKeyMap converts map[interface{}]interface{} to map[string]interface{}
 func convertToStringKeyMap(m map[interface{}]interface{}) map[string]interface{} {
 	result := make(map[string]interface{})

internal/executor/resource_executor_test.go

@@ -620,11 +620,9 @@ data:
 		execCtx := NewExecutionContext(context.Background(), nil, nil)
 		execCtx.Params = map[string]interface{}{}
 
-		// Empty YAML produces nil map, which marshals to JSON "null"
-		// The executor will fail downstream when trying to use the null manifest
-		data, err := re.renderToBytes(context.Background(), resource, execCtx)
-		require.NoError(t, err) // renderToBytes succeeds — error happens at apply time
-		assert.Equal(t, "null", string(data))
+		_, err := re.renderToBytes(context.Background(), resource, execCtx)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "empty manifest")
 	})
 
 	t.Run("template rendering produces invalid YAML", func(t *testing.T) {
@@ -768,3 +766,80 @@ data:
 	assert.True(t, found)
 	assert.Equal(t, "cluster-1", data)
 }
+
+func TestResolveGVK_StringManifest(t *testing.T) {
+	re := &ResourceExecutor{}
+
+	tests := []struct {
+		name        string
+		manifest    interface{}
+		wantGroup   string
+		wantVersion string
+		wantKind    string
+		wantEmpty   bool
+	}{
+		{
+			name: "map manifest",
+			manifest: map[string]interface{}{
+				"apiVersion": "v1",
+				"kind":       "ConfigMap",
+			},
+			wantVersion: "v1",
+			wantKind:    "ConfigMap",
+		},
+		{
+			name:        "string manifest with Go templates",
+			manifest:    "apiVersion: v1\nkind: ConfigMap\nmetadata:\n  name: \"{{ .clusterId }}\"\n",
+			wantVersion: "v1",
+			wantKind:    "ConfigMap",
+		},
+		{
+			name: "string manifest with structural Go template directives",
+			manifest: "apiVersion: v1\nkind: ConfigMap\nmetadata:\n" +
+				"  name: \"test-{{ .clusterId }}\"\n  labels:\n    app: test\n" +
+				"{{ if .testRunId }}\n    run-id: \"{{ .testRunId }}\"\n{{ end }}\n" +
+				"data:\n  key: value\n",
+			wantVersion: "v1",
+			wantKind:    "ConfigMap",
+		},
+		{
+			name:        "string manifest with apps/v1",
+			manifest:    "apiVersion: apps/v1\nkind: Deployment\n",
+			wantGroup:   "apps",
+			wantVersion: "v1",
+			wantKind:    "Deployment",
+		},
+		{
+			name:      "nil manifest",
+			manifest:  nil,
+			wantEmpty: true,
+		},
+		{
+			name:      "invalid string YAML",
+			manifest:  "not: valid: yaml: {{{}",
+			wantEmpty: true,
+		},
+		{
+			name:      "string manifest missing kind",
+			manifest:  "apiVersion: v1\nmetadata:\n  name: test\n",
+			wantEmpty: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			resource := configloader.Resource{
+				Manifest: tt.manifest,
+			}
+			gvk := re.resolveGVK(resource)
+
+			if tt.wantEmpty {
+				assert.True(t, gvk.Empty(), "expected empty GVK")
+			} else {
+				assert.Equal(t, tt.wantGroup, gvk.Group)
+				assert.Equal(t, tt.wantVersion, gvk.Version)
+				assert.Equal(t, tt.wantKind, gvk.Kind)
+			}
+		})
+	}
+}