v2025-09.2 (#263)

Author: laszlocph

README.md

@@ -49,3 +49,43 @@ Reach out to laszlo at gimlet.io. We are looking for beta testers.
 ![Star History Chart](https://api.star-history.com/svg?repos=gimlet-io/capacitor&type=Date)
 
 Please push ✨
+
+## Versioning
+
+Capacitor Next follows a calendar based versioning with a bi-weekly feature release cadence.
+
+- `v2025-09.1` is the first feature release in September 2025. Landing mid month.
+- `v2025-09.2` is the second feature release in September 2025. Landing at the end of the month, or perhaps the beginning of the next one.
+- `v2025-09.1-patch1` is the first patch release of the first feature release in September 2025.
+- `v2025-09.2-rc2` is the second release candidate of the second feature release in September 2025.
+- `v2025-09.2-debug1` is a debug release of the second feature release in September 2025. Meant to be installed only by request of the maintainers.
+
+The update notifications in the UI trigger only on feature releases: `v2025-09.1`, `v2025-09.2`.
+
+You may install `patch` and `rc` releases if you please, `debug` releases if requested.
+
+You can install a specific version by supplying the version tag:
+
+```
+wget -qO- https://gimlet.io/install-capacitor | bash -s -- v2025-09.2
+```
+
+### Branching
+
+`main` is always the latest feature release. Late September 2025 that is `v2025-09.1` as `v2025-09.2` is not released yet. `main` carries patch and debug releases of the latest feature release.
+
+The next feature release is built on a branch named after it eg.: `v2025-09.2`. Rc and debug releases are built from this branch.
+
+### Self-hosted versioning
+
+Versioning for the self-hosted release follows the versioning of the local-first app.
+
+The deployment yamls always point to the latest feture release or its latest patch release.
+
+- Self-hosted fixes are released in a patch version `v2025-09.1-patch1` even if the local-first app does not have any changes. The auto-update message ignores patch versions, therefor the self-hosted version does not interfere with the local-first experience.
+
+- The self-hosted version does not publish an image with rc tag of the next feature release. New features are meant to be tested in the local-first app.
+
+- The self-hosted version do publish images with the debug tag. It is crucial to grow robust support for all environments. These are meant to be installed on request and the contents are not publicly documented.
+
+- The self-hosted version may introduce new features in a patch tag. Only for new features that are strictly related to the self-hosted experience.

cli/pkg/server/k8s_proxy.go

@@ -1,6 +1,8 @@
 package server
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"io"
 	"log"
@@ -58,6 +60,40 @@ func NewKubernetesProxy(k8sClient *kubernetes.Client) (*KubernetesProxy, error)
 	// Set the custom transport with TLS config
 	proxy.Transport = transport
 
+	// Strip metadata.managedFields from JSON responses
+	proxy.ModifyResponse = func(resp *http.Response) error {
+		// Skip if this is a watch stream; we don't buffer streaming responses here
+		if resp != nil && resp.Request != nil {
+			q := resp.Request.URL.Query().Get("watch")
+			if strings.EqualFold(q, "true") || q == "1" {
+				return nil
+			}
+		}
+
+		// Skip compressed or non-JSON responses
+		if enc := resp.Header.Get("Content-Encoding"); enc != "" && enc != "identity" {
+			return nil
+		}
+		ct := resp.Header.Get("Content-Type")
+		if !strings.Contains(ct, "json") {
+			return nil
+		}
+
+		// Read, filter, and replace body
+		body, err := io.ReadAll(resp.Body)
+		if err != nil {
+			return err
+		}
+		_ = resp.Body.Close()
+
+		filtered := stripManagedFieldsFromBytes(body)
+
+		resp.Body = io.NopCloser(bytes.NewReader(filtered))
+		resp.ContentLength = int64(len(filtered))
+		resp.Header.Set("Content-Length", fmt.Sprintf("%d", len(filtered)))
+		return nil
+	}
+
 	// Customize error handling
 	proxy.ErrorHandler = func(w http.ResponseWriter, r *http.Request, err error) {
 		log.Printf("Error proxying request to Kubernetes API: %v", err)
@@ -100,3 +136,45 @@ func (p *KubernetesProxy) HandleAPIRequest(c echo.Context) error {
 
 	return nil
 }
+
+// stripManagedFieldsFromBytes removes metadata.managedFields fields from any JSON structure.
+// On error, it returns the original input.
+func stripManagedFieldsFromBytes(in []byte) []byte {
+	if len(in) == 0 {
+		return in
+	}
+	var v interface{}
+	if err := json.Unmarshal(in, &v); err != nil {
+		return in
+	}
+	removeManagedFieldsFromAny(&v)
+	b, err := json.Marshal(v)
+	if err != nil {
+		return in
+	}
+	return b
+}
+
+// removeManagedFieldsFromAny walks arbitrarily nested maps/slices and deletes metadata.managedFields.
+func removeManagedFieldsFromAny(v *interface{}) {
+	switch t := (*v).(type) {
+	case map[string]interface{}:
+		if meta, ok := t["metadata"].(map[string]interface{}); ok {
+			delete(meta, "managedFields")
+		}
+		for k, child := range t {
+			// Recurse into children
+			c := interface{}(child)
+			removeManagedFieldsFromAny(&c)
+			t[k] = c
+		}
+	case []interface{}:
+		for i, child := range t {
+			c := interface{}(child)
+			removeManagedFieldsFromAny(&c)
+			t[i] = c
+		}
+	default:
+		// primitives: nothing to do
+	}
+}

cli/pkg/server/server.go

@@ -110,6 +110,13 @@ func (s *Server) Setup() {
 		return func(c echo.Context) error {
 			ctxName := c.Param("context")
 			if strings.TrimSpace(ctxName) != "" {
+				// URL decode the context name to handle special characters like @
+				ctxName, err := url.PathUnescape(ctxName)
+				if err != nil {
+					return c.JSON(http.StatusBadRequest, map[string]string{
+						"error": fmt.Sprintf("failed to decode context name: %v", err),
+					})
+				}
 				proxy, err := s.getOrCreateK8sProxyForContext(ctxName)
 				if err != nil {
 					status := http.StatusInternalServerError
@@ -154,6 +161,14 @@ func (s *Server) Setup() {
 			})
 		}
 
+		// URL decode the context name to handle special characters like @
+		ctxName, err := url.PathUnescape(ctxName)
+		if err != nil {
+			return c.JSON(http.StatusBadRequest, map[string]string{
+				"error": fmt.Sprintf("failed to decode context name: %v", err),
+			})
+		}
+
 		proxy, err := s.getOrCreateK8sProxyForContext(ctxName)
 		if err != nil {
 			status := http.StatusInternalServerError
@@ -1062,6 +1077,29 @@ func (s *Server) Setup() {
 		})
 	})
 
+	// Add endpoints for listing Helm releases (context-aware) with optional Table response
+	// Support trailing resource segment to match client list path construction
+	s.echo.GET("/api/:context/helm/releases/releases", func(c echo.Context) error {
+		proxy, ok := getProxyFromContext(c)
+		if !ok {
+			return c.JSON(http.StatusBadRequest, map[string]string{"error": "missing proxy in context"})
+		}
+		return s.handleHelmReleasesList(c, proxy, "")
+	})
+
+	// Support trailing resource segment for namespaced path as well
+	s.echo.GET("/api/:context/helm/releases/namespaces/:namespace/releases", func(c echo.Context) error {
+		proxy, ok := getProxyFromContext(c)
+		if !ok {
+			return c.JSON(http.StatusBadRequest, map[string]string{"error": "missing proxy in context"})
+		}
+		ns := c.Param("namespace")
+		if strings.EqualFold(ns, "all-namespaces") {
+			ns = ""
+		}
+		return s.handleHelmReleasesList(c, proxy, ns)
+	})
+
 	// Add endpoint for Helm release rollback (context-aware)
 	s.echo.POST("/api/:context/helm/rollback/:namespace/:name/:revision", func(c echo.Context) error {
 		proxy, ok := getProxyFromContext(c)
@@ -1169,6 +1207,124 @@ func (s *Server) getOrCreateK8sProxyForContext(contextName string) (*KubernetesP
 	return proxy, nil
 }
 
+// handleHelmReleasesList lists Helm releases and returns either a Kubernetes Table or a plain List
+func (s *Server) handleHelmReleasesList(c echo.Context, proxy *KubernetesProxy, namespace string) error {
+	hc, err := helm.NewClient(proxy.k8sClient.Config, "")
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{
+			"error": fmt.Sprintf("failed to create helm client: %v", err),
+		})
+	}
+
+	releases, err := hc.ListReleases(c.Request().Context(), namespace)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{
+			"error": fmt.Sprintf("Failed to list Helm releases: %v", err),
+		})
+	}
+
+	accept := c.Request().Header.Get("Accept")
+	if strings.Contains(accept, "as=Table;g=meta.k8s.io;v=v1") {
+		table := buildHelmReleasesTable(releases)
+		return c.JSON(http.StatusOK, table)
+	}
+
+	// Default JSON list fallback
+	items := make([]map[string]interface{}, 0, len(releases))
+	for _, rel := range releases {
+		items = append(items, buildHelmReleaseObject(rel))
+	}
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"kind":       "List",
+		"apiVersion": "v1",
+		"items":      items,
+	})
+}
+
+// buildHelmReleaseObject converts a Helm release to a Kubernetes-like object
+func buildHelmReleaseObject(release *helm.Release) map[string]interface{} {
+	return map[string]interface{}{
+		"apiVersion": "helm.sh/v3",
+		"kind":       "Release",
+		"metadata": map[string]interface{}{
+			"name":              release.Name,
+			"namespace":         release.Namespace,
+			"creationTimestamp": release.Updated.Format(time.RFC3339),
+		},
+		"spec": map[string]interface{}{
+			"chart":        release.Chart,
+			"chartVersion": release.ChartVersion,
+			"values":       release.Values,
+		},
+		"status": map[string]interface{}{
+			"status":     release.Status,
+			"revision":   release.Revision,
+			"appVersion": release.AppVersion,
+			"notes":      release.Notes,
+		},
+	}
+}
+
+// buildHelmReleasesTable constructs a meta.k8s.io/v1 Table response for Helm releases
+func buildHelmReleasesTable(releases []*helm.Release) map[string]interface{} {
+	columnDefinitions := []map[string]interface{}{
+		{"name": "Name", "type": "string", "format": "name"},
+		{"name": "Chart", "type": "string"},
+		{"name": "App Version", "type": "string"},
+		{"name": "Status", "type": "string"},
+		{"name": "Revision", "type": "string"},
+		{"name": "Age", "type": "string"},
+	}
+
+	rows := make([]map[string]interface{}, 0, len(releases))
+	now := time.Now()
+	for _, rel := range releases {
+		age := humanizeDuration(now.Sub(rel.Updated))
+		chart := rel.Chart
+		if rel.ChartVersion != "" {
+			chart = fmt.Sprintf("%s (%s)", rel.Chart, rel.ChartVersion)
+		}
+		cells := []interface{}{
+			rel.Name,
+			chart,
+			rel.AppVersion,
+			rel.Status,
+			fmt.Sprintf("%d", rel.Revision),
+			age,
+		}
+		rows = append(rows, map[string]interface{}{
+			"cells":  cells,
+			"object": buildHelmReleaseObject(rel),
+		})
+	}
+
+	return map[string]interface{}{
+		"kind":              "Table",
+		"apiVersion":        "meta.k8s.io/v1",
+		"columnDefinitions": columnDefinitions,
+		"rows":              rows,
+	}
+}
+
+// humanizeDuration returns a short human-readable duration like 5m, 2h, 3d
+func humanizeDuration(d time.Duration) string {
+	if d < time.Minute {
+		s := int(d.Seconds())
+		if s <= 0 {
+			return "0s"
+		}
+		return fmt.Sprintf("%ds", s)
+	}
+	if d < time.Hour {
+		return fmt.Sprintf("%dm", int(d.Minutes()))
+	}
+	if d < 24*time.Hour {
+		return fmt.Sprintf("%dh", int(d.Hours()))
+	}
+	days := int(d.Hours()) / 24
+	return fmt.Sprintf("%dd", days)
+}
+
 // downloadAndExtractArtifact downloads and extracts a Flux source artifact
 func (s *Server) downloadAndExtractArtifact(ctx context.Context, client *kubernetes.Client, artifactURL string) (string, error) {
 	// Create a temporary directory