feat: iterating on fluxcd support (#300)

* feat: HR events

* tinkering

* tinkering

* feat: clear logs

* feat: stalled hr badge

* ux

* ui thing

* fix: resetting filters if you change resourec types

* fix: restore url state

Author: laszlocph

cli/pkg/server/k8s_proxy.go

@@ -5,6 +5,7 @@ package server
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -13,16 +14,21 @@ import (
 	"net/http/httputil"
 	"net/url"
 	"strings"
+	"sync"
 
 	"github.com/gimlet-io/capacitor/pkg/kubernetes"
 	"github.com/labstack/echo/v4"
+	"k8s.io/client-go/discovery"
 	"k8s.io/client-go/rest"
 )
 
 // KubernetesProxy handles proxying requests to the Kubernetes API
 type KubernetesProxy struct {
-	k8sClient *kubernetes.Client
-	proxy     *httputil.ReverseProxy
+	k8sClient        *kubernetes.Client
+	proxy            *httputil.ReverseProxy
+	fluxAPIPaths     map[string]string // Cache for discovered Flux API paths (kind -> API path template)
+	fluxAPIPathsMu   sync.RWMutex      // Mutex for thread-safe access to fluxAPIPaths
+	fluxAPIDiscovery sync.Once         // Ensures discovery happens only once
 }
 
 // NewKubernetesProxy creates a new KubernetesProxy
@@ -105,8 +111,9 @@ func NewKubernetesProxy(k8sClient *kubernetes.Client) (*KubernetesProxy, error)
 	}
 
 	return &KubernetesProxy{
-		k8sClient: k8sClient,
-		proxy:     proxy,
+		k8sClient:    k8sClient,
+		proxy:        proxy,
+		fluxAPIPaths: make(map[string]string),
 	}, nil
 }
 
@@ -172,3 +179,138 @@ func removeManagedFieldsFromAny(v *interface{}) {
 		// primitives: nothing to do
 	}
 }
+
+// discoverFluxAPIPaths discovers Flux API paths using Kubernetes discovery client
+// Returns a map of resource kind to API path template (e.g., "Kustomization" -> "/apis/kustomize.toolkit.fluxcd.io/v1/namespaces/%s/kustomizations/%s")
+// Uses sync.Once to ensure discovery happens only once per proxy instance
+func (p *KubernetesProxy) discoverFluxAPIPaths() (map[string]string, error) {
+	var discoveryErr error
+
+	// Use sync.Once to ensure discovery happens only once
+	p.fluxAPIDiscovery.Do(func() {
+		// Create discovery client
+		discoveryClient, err := discovery.NewDiscoveryClientForConfig(p.k8sClient.Config)
+		if err != nil {
+			discoveryErr = fmt.Errorf("failed to create discovery client: %w", err)
+			return
+		}
+
+		// Get API groups
+		apiGroups, err := discoveryClient.ServerGroups()
+		if err != nil {
+			discoveryErr = fmt.Errorf("failed to get API groups: %w", err)
+			return
+		}
+
+		// Map of Flux API group prefixes to their resource kinds
+		fluxGroupKinds := map[string][]string{
+			"kustomize.toolkit.fluxcd.io":    {"Kustomization"},
+			"helm.toolkit.fluxcd.io":         {"HelmRelease"},
+			"source.toolkit.fluxcd.io":       {"GitRepository", "HelmRepository", "HelmChart", "OCIRepository", "Bucket"},
+			"notification.toolkit.fluxcd.io": {"Alert", "Provider", "Receiver"},
+			"image.toolkit.fluxcd.io":        {"ImagePolicy", "ImageRepository", "ImageUpdate"},
+			"infra.contrib.fluxcd.io":        {"Terraform"},
+		}
+
+		// Map of resource kind to plural form
+		kindToPlural := map[string]string{
+			"Kustomization":   "kustomizations",
+			"HelmRelease":     "helmreleases",
+			"GitRepository":   "gitrepositories",
+			"HelmRepository":  "helmrepositories",
+			"HelmChart":       "helmcharts",
+			"OCIRepository":   "ocirepositories",
+			"Bucket":          "buckets",
+			"Alert":           "alerts",
+			"Provider":        "providers",
+			"Receiver":        "receivers",
+			"ImagePolicy":     "imagepolicies",
+			"ImageRepository": "imagerepositories",
+			"ImageUpdate":     "imageupdateautomations",
+			"Terraform":       "terraforms",
+		}
+
+		discoveredPaths := make(map[string]string)
+
+		// Iterate through API groups to find Flux groups
+		for _, group := range apiGroups.Groups {
+			for groupPrefix, kinds := range fluxGroupKinds {
+				if strings.Contains(group.Name, groupPrefix) {
+					// Find the preferred version
+					preferredVersion := group.PreferredVersion.Version
+					if preferredVersion == "" && len(group.Versions) > 0 {
+						preferredVersion = group.Versions[0].Version
+					}
+
+					// Get resources for this group version
+					groupVersion := fmt.Sprintf("%s/%s", group.Name, preferredVersion)
+					resources, err := discoveryClient.ServerResourcesForGroupVersion(groupVersion)
+					if err != nil {
+						log.Printf("Warning: failed to get resources for %s: %v", groupVersion, err)
+						continue
+					}
+
+					// Map each kind to its API path
+					for _, kind := range kinds {
+						plural, ok := kindToPlural[kind]
+						if !ok {
+							log.Printf("Warning: no plural form found for kind %s", kind)
+							continue
+						}
+
+						// Check if this resource exists in the discovered resources
+						found := false
+						for _, resource := range resources.APIResources {
+							if resource.Name == plural {
+								found = true
+								break
+							}
+						}
+
+						if found {
+							// Build API path template: /apis/{group}/{version}/namespaces/{namespace}/{plural}/{name}
+							apiPath := fmt.Sprintf("/apis/%s/%s/namespaces/%%s/%s/%%s", group.Name, preferredVersion, plural)
+							discoveredPaths[kind] = apiPath
+						}
+					}
+				}
+			}
+		}
+
+		// Cache the results
+		p.fluxAPIPathsMu.Lock()
+		p.fluxAPIPaths = discoveredPaths
+		p.fluxAPIPathsMu.Unlock()
+	})
+
+	// Return error if discovery failed
+	if discoveryErr != nil {
+		return nil, discoveryErr
+	}
+
+	// Return cached results (thread-safe read)
+	p.fluxAPIPathsMu.RLock()
+	defer p.fluxAPIPathsMu.RUnlock()
+
+	// Return a copy to prevent external modification
+	result := make(map[string]string, len(p.fluxAPIPaths))
+	for k, v := range p.fluxAPIPaths {
+		result[k] = v
+	}
+	return result, nil
+}
+
+// getFluxAPIPath returns the API path for a Flux resource kind, discovering it if necessary
+func (p *KubernetesProxy) getFluxAPIPath(ctx context.Context, kind string) (string, error) {
+	paths, err := p.discoverFluxAPIPaths()
+	if err != nil {
+		return "", err
+	}
+
+	apiPath, found := paths[kind]
+	if !found {
+		return "", fmt.Errorf("flux resource kind %s not found in discovered API paths", kind)
+	}
+
+	return apiPath, nil
+}