Memby v0.1.53: Android TV client plus gateway

Android TV client for Emby (Kotlin, Compose for TV) and the Memby gateway
(Go, Postgres, Redis) that fronts it.

Client:
- Setup, profiles, home rows, Media3 playback, system screensaver (Dream)
- Backend chosen at build time: gateway when memby.gatewayUrl is set,
  otherwise direct to Emby. Both paths stay working.
- Server-composed home rows, rendered verbatim so new row types ship
  without an app release
- Full-screen animated maintenance state, row engagement telemetry

Gateway:
- One request per TV screen; auth, caching, search and row shaping
- Library import from Emby into Postgres (manual, then hourly incremental)
- Recommendations from viewing history (recency-weighted genre affinity)
- Admin page for imports, an offline switch, and per-row analytics
- Video always direct-plays from Emby; only metadata passes through

Identity is com.ponzischeme89.memby throughout, replacing
com.mattcohen.embyclientsname. A changed applicationId installs as a new
app: TVs need a fresh sign-in and the old package uninstalled.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

server/internal/api/images.go

@@ -0,0 +1,65 @@
+package api
+
+import (
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/ponzischeme89/memby/server/internal/store"
+)
+
+// allowedImageTypes guards the path segment we forward to Emby.
+var allowedImageTypes = map[string]string{
+	"backdrop": "Backdrop",
+	"primary":  "Primary",
+	"logo":     "Logo",
+	"thumb":    "Thumb",
+}
+
+// handleImage proxies artwork.
+//
+// Going through the gateway means the TV's image URLs carry a gateway token instead of a
+// live Emby api_key, and it gives Emby's resized output a cacheable home. Images are
+// tag-addressed, so a hit can be cached hard by any layer in front of this.
+func (s *Server) handleImage(w http.ResponseWriter, r *http.Request, sess store.Session) {
+	itemID := r.PathValue("itemId")
+	imageType, ok := allowedImageTypes[strings.ToLower(r.PathValue("imageType"))]
+	if !ok || itemID == "" {
+		writeError(w, http.StatusNotFound, "unknown image")
+		return
+	}
+
+	params := url.Values{}
+	for _, key := range []string{"tag", "maxWidth", "maxHeight", "quality"} {
+		if v := r.URL.Query().Get(key); v != "" {
+			params.Set(key, v)
+		}
+	}
+
+	resp, err := s.emby.ImageResponse(r.Context(), credentials(sess), itemID, imageType, params)
+	if err != nil {
+		s.writeUpstreamError(w, err, "could not load the image")
+		return
+	}
+	defer resp.Body.Close()
+
+	if ct := resp.Header.Get("Content-Type"); ct != "" {
+		w.Header().Set("Content-Type", ct)
+	}
+	if cl := resp.Header.Get("Content-Length"); cl != "" {
+		w.Header().Set("Content-Length", cl)
+	}
+	// A tag identifies exact image bytes, so it can be cached indefinitely. Without one,
+	// stay conservative.
+	if params.Get("tag") != "" {
+		w.Header().Set("Cache-Control", "private, max-age=31536000, immutable")
+	} else {
+		w.Header().Set("Cache-Control", "private, max-age=3600")
+	}
+
+	w.WriteHeader(http.StatusOK)
+	if _, err := io.Copy(w, resp.Body); err != nil {
+		s.log.Warn("image copy failed", "error", err)
+	}
+}