Idle sessions sign themselves out; a KVM's login is remembered; the compose editor knows YAML

A session unused for seven days is dropped, the Sessions list marks a day's idleness and
can sign all of those out at once. The hub keeps a KVM's own cookies from any browser that
has them and lends them to one that hasn't, on the wire and back to the page. The stack
editor and the new-stack dialog use CodeEditor: line numbers, YAML and .env colour under a
real textarea, Tab/Shift+Tab/Enter indentation, and a key bar on touch screens.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

internal/api/kvm.go

@@ -31,6 +31,7 @@ import (
 	"time"
 
 	"hamlab/internal/config"
+	"hamlab/internal/store"
 )
 
 const kvmPrefix = "/kvm/"
@@ -82,9 +83,25 @@ func (s *Server) kvmProxy(k config.KVM) (*httputil.ReverseProxy, error) {
 			}
 			r.URL.RawPath = ""
 			r.Host = target.Host
+			// Whether the console itself is on TLS: the response rewriter needs to know, and by
+			// then only the outbound request is in hand.
+			if secure(r) {
+				r.Header.Set(kvmSecureHeader, "1")
+			} else {
+				r.Header.Del(kvmSecureHeader)
+			}
 			// The device gets its own host and none of Ham Lab's session.
 			r.Header.Del("Origin")
 			stripCookie(r, cookieName, kvmCookie)
+			// What is left is the device's own login. A browser that has it teaches the hub; one
+			// that has not is lent what the hub remembers, so the device sees a signed-in client.
+			if own := r.Cookies(); len(own) > 0 {
+				s.rememberKVMCookies(k.ID, own)
+			} else {
+				for name, val := range s.kvmCookies(k.ID) {
+					r.AddCookie(&http.Cookie{Name: name, Value: val})
+				}
+			}
 		},
 		FlushInterval: -1, // a video stream must not be buffered
 		ModifyResponse: func(resp *http.Response) error {
@@ -94,6 +111,24 @@ func (s *Server) kvmProxy(k config.KVM) (*httputil.ReverseProxy, error) {
 			for _, h := range []string{"X-Frame-Options", "Content-Security-Policy", "Content-Security-Policy-Report-Only", "Strict-Transport-Security", "Referrer-Policy"} {
 				resp.Header.Del(h)
 			}
+			// A cookie the device sets by header is kept for Ham Lab's origin — so its Domain
+			// (the device's) goes, Secure follows the console rather than the device, and the
+			// hub remembers it too.
+			if set := resp.Cookies(); len(set) > 0 {
+				https := resp.Request != nil && resp.Request.Header.Get(kvmSecureHeader) == "1"
+				resp.Header.Del("Set-Cookie")
+				for _, c := range set {
+					c.Domain = ""
+					if c.Path == "" {
+						c.Path = "/"
+					}
+					c.Secure = c.Secure && https
+					if v := c.String(); v != "" {
+						resp.Header.Add("Set-Cookie", v)
+					}
+				}
+				s.rememberKVMCookies(k.ID, set)
+			}
 			// A redirect to the device's own root has to come back through the prefix.
 			if loc := resp.Header.Get("Location"); loc != "" {
 				if u, err := url.Parse(loc); err == nil && (u.Host == "" || u.Host == target.Host) && strings.HasPrefix(u.Path, "/") && !strings.HasPrefix(u.Path, prefix) {
@@ -114,6 +149,93 @@ func (s *Server) kvmProxy(k config.KVM) (*httputil.ReverseProxy, error) {
 	return p, nil
 }
 
+// kvmSecureHeader rides on the outbound request to say whether the console was reached
+// over TLS; the device ignores it.
+const kvmSecureHeader = "X-Hamlab-Secure"
+
+// kvmCookies is what the hub remembers of a device's own cookies — its login, in practice.
+func (s *Server) kvmCookies(id string) map[string]string {
+	var out map[string]string
+	s.store.View(func(st *store.State) {
+		if m := st.KVMCookies[id]; len(m) > 0 {
+			out = make(map[string]string, len(m))
+			for k, v := range m {
+				out[k] = v
+			}
+		}
+	})
+	return out
+}
+
+// rememberKVMCookies keeps the cookies a browser (or the device's own Set-Cookie) carries
+// for a KVM, so that a browser without them can be lent them. A cookie emptied or expired
+// by the device is forgotten. Written only when something changed: this runs on every
+// proxied request.
+func (s *Server) rememberKVMCookies(id string, cs []*http.Cookie) {
+	have := s.kvmCookies(id)
+	changed := false
+	for _, c := range cs {
+		if c.Name == "" || c.Name == cookieName || c.Name == kvmCookie {
+			continue
+		}
+		gone := c.Value == "" || c.MaxAge < 0 || (!c.Expires.IsZero() && c.Expires.Before(time.Now()))
+		if gone {
+			if _, ok := have[c.Name]; ok {
+				changed = true
+			}
+			continue
+		}
+		if have[c.Name] != c.Value {
+			changed = true
+		}
+	}
+	if !changed {
+		return
+	}
+	_ = s.store.Update(func(st *store.State) {
+		if st.KVMCookies == nil {
+			st.KVMCookies = map[string]map[string]string{}
+		}
+		m := st.KVMCookies[id]
+		if m == nil {
+			m = map[string]string{}
+		}
+		for _, c := range cs {
+			if c.Name == "" || c.Name == cookieName || c.Name == kvmCookie {
+				continue
+			}
+			if c.Value == "" || c.MaxAge < 0 || (!c.Expires.IsZero() && c.Expires.Before(time.Now())) {
+				delete(m, c.Name)
+			} else {
+				m[c.Name] = c.Value
+			}
+		}
+		if len(m) == 0 {
+			delete(st.KVMCookies, id)
+		} else {
+			st.KVMCookies[id] = m
+		}
+	})
+}
+
+// forgetKVMCookies drops a device's remembered login — when the device is removed.
+func (s *Server) forgetKVMCookies(id string) {
+	_ = s.store.Update(func(st *store.State) { delete(st.KVMCookies, id) })
+}
+
+// lendKVMCookies hands the browser the device cookies the hub remembers and it lacks, as
+// the device's own page would have set them: readable by its scripts, for Ham Lab's whole
+// origin, kept for half a year. The device's SPA checks for its token client-side before it
+// ever asks the server, so lending it only on the wire would still land on the login form.
+func (s *Server) lendKVMCookies(w http.ResponseWriter, r *http.Request, id string) {
+	for name, val := range s.kvmCookies(id) {
+		if _, err := r.Cookie(name); err == nil {
+			continue
+		}
+		http.SetCookie(w, &http.Cookie{Name: name, Value: val, Path: "/", MaxAge: 180 * 24 * 3600, Secure: secure(r), SameSite: http.SameSiteLaxMode})
+	}
+}
+
 // stripCookie removes named cookies from a request, so Ham Lab's session is never handed to
 // a device and the device never sees which KVM the browser is looking at.
 func stripCookie(r *http.Request, names ...string) {
@@ -157,6 +279,7 @@ func (s *Server) serveKVM(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	http.SetCookie(w, &http.Cookie{Name: kvmCookie, Value: id, Path: "/", HttpOnly: true, Secure: secure(r), SameSite: http.SameSiteLaxMode})
+	s.lendKVMCookies(w, r, id)
 	p.ServeHTTP(w, r)
 }
 
@@ -305,6 +428,7 @@ func (s *Server) removeKVM(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	s.forgetKVMProxy(id)
+	s.forgetKVMCookies(id)
 	log.Printf("kvm %s removed by %s", id, clientIP(r))
 	w.WriteHeader(204)
 }

internal/api/kvm_test.go

@@ -0,0 +1,123 @@
+package api
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"hamlab/internal/auth"
+	"hamlab/internal/config"
+	"hamlab/internal/store"
+)
+
+// A KVM's own login is a cookie its page sets in one browser. The hub remembers it from the
+// requests that carry it, lends it to a browser that lacks it — both on the wire to the
+// device and back to the browser, since the device's page checks for it client-side — and
+// forgets it when the device says it is gone or the KVM is removed.
+func TestKVMCookiesAreRememberedAndLent(t *testing.T) {
+	var seen []string // the Cookie header the fake device received, per request
+	device := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		seen = append(seen, r.Header.Get("Cookie"))
+		if r.URL.Path == "/api/auth/login" {
+			// a device that sets its token by header, with its own domain and Secure
+			http.SetCookie(w, &http.Cookie{Name: "nano-kvm-token", Value: "tok-1", Domain: "10.0.0.217", Secure: true})
+		}
+		if r.URL.Path == "/api/auth/logout" {
+			http.SetCookie(w, &http.Cookie{Name: "nano-kvm-token", Value: "", MaxAge: -1})
+		}
+		w.WriteHeader(200)
+	}))
+	defer device.Close()
+
+	dir := t.TempDir()
+	cfg := config.Default(filepath.Join(dir, "config.json"))
+	if err := cfg.Update(func(c *config.Config) {
+		c.KVMs = []config.KVM{{ID: "abc123", Name: "test", URL: device.URL, Machine: ""}}
+	}); err != nil {
+		t.Fatal(err)
+	}
+	st, err := store.Open(filepath.Join(dir, "state.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := &Server{cfg: cfg, store: st, sessions: auth.NewSessions(st)}
+	k, _ := s.kvm("abc123")
+	p, err := s.kvmProxy(k)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ask := func(path string, cookies ...*http.Cookie) *httptest.ResponseRecorder {
+		r := httptest.NewRequest("GET", path, nil)
+		r.SetPathValue("id", "abc123")
+		for _, c := range cookies {
+			r.AddCookie(c)
+		}
+		w := httptest.NewRecorder()
+		if strings.HasPrefix(path, kvmPrefix) {
+			s.serveKVM(w, r)
+		} else {
+			p.ServeHTTP(w, r)
+		}
+		return w
+	}
+
+	// 1. the device sets its token by header: it reaches the browser without the device's
+	//    domain or Secure (plain-http console), and the hub remembers it
+	w := ask("/api/auth/login", &http.Cookie{Name: cookieName, Value: "hamlab-session"})
+	var set *http.Cookie
+	for _, c := range w.Result().Cookies() {
+		if c.Name == "nano-kvm-token" {
+			set = c
+		}
+	}
+	if set == nil || set.Domain != "" || set.Secure || set.Value != "tok-1" || set.Path != "/" {
+		t.Fatalf("rewritten Set-Cookie = %+v, want nano-kvm-token=tok-1 for / without Domain or Secure", set)
+	}
+	if got := s.kvmCookies("abc123"); got["nano-kvm-token"] != "tok-1" {
+		t.Fatalf("remembered = %v, want the token", got)
+	}
+	if strings.Contains(seen[0], "hamlab_session") {
+		t.Fatalf("the device was handed Ham Lab's session: %q", seen[0])
+	}
+
+	// 2. a browser that has the cookie teaches a newer value
+	ask("/api/vm/info", &http.Cookie{Name: "nano-kvm-token", Value: "tok-2"}, &http.Cookie{Name: cookieName, Value: "x"})
+	if got := s.kvmCookies("abc123"); got["nano-kvm-token"] != "tok-2" {
+		t.Fatalf("remembered = %v, want tok-2", got)
+	}
+	if seen[1] != "nano-kvm-token=tok-2" {
+		t.Fatalf("device saw %q, want the browser's own cookie only", seen[1])
+	}
+
+	// 3. a browser without it is lent it: on the wire, and back as a Set-Cookie it can read
+	w = ask(kvmPrefix+"abc123/", &http.Cookie{Name: cookieName, Value: "x"})
+	if seen[2] != "nano-kvm-token=tok-2" {
+		t.Fatalf("device saw %q from a browser with no cookie, want the remembered token", seen[2])
+	}
+	lent := false
+	for _, c := range w.Result().Cookies() {
+		if c.Name == "nano-kvm-token" && c.Value == "tok-2" && !c.HttpOnly && c.Path == "/" && c.MaxAge > 0 {
+			lent = true
+		}
+	}
+	if !lent {
+		t.Fatalf("browser was not lent the token: %v", w.Result().Cookies())
+	}
+
+	// 4. the device logging out forgets it
+	ask("/api/auth/logout", &http.Cookie{Name: "nano-kvm-token", Value: "tok-2"})
+	if got := s.kvmCookies("abc123"); got != nil {
+		t.Fatalf("after logout remembered = %v, want nothing", got)
+	}
+
+	// 5. removing the KVM clears whatever is left
+	s.rememberKVMCookies("abc123", []*http.Cookie{{Name: "nano-kvm-token", Value: "tok-3"}})
+	s.forgetKVMCookies("abc123")
+	if got := s.kvmCookies("abc123"); got != nil {
+		t.Fatalf("after remove remembered = %v, want nothing", got)
+	}
+	_ = url.Parse
+}

internal/api/server.go

@@ -320,6 +320,7 @@ func (s *Server) routes() *http.ServeMux {
 	m.HandleFunc("GET /api/sessions", s.auth(s.listSessions))
 	m.HandleFunc("DELETE /api/sessions/{id}", s.auth(s.revokeSession))
 	m.HandleFunc("POST /api/sessions/revoke-others", s.auth(s.revokeOtherSessions))
+	m.HandleFunc("POST /api/sessions/revoke-idle", s.auth(s.revokeIdleSessions))
 	m.HandleFunc("GET /api/prefs/ui", s.auth(s.getUIPrefs))
 	m.HandleFunc("PUT /api/prefs/ui", s.auth(s.putUIPrefs))
 	// Go runtime profiles, behind the login, for chasing memory/CPU (bug 14).

internal/api/users.go

@@ -12,6 +12,7 @@ import (
 	"io"
 	"log"
 	"net/http"
+	"strconv"
 	"strings"
 	"time"
 
@@ -264,6 +265,29 @@ func (s *Server) revokeSession(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(204)
 }
 
+// revokeIdleSessions drops the caller's sessions that have not been used for ?hours (24 by
+// default): the scripts and headless browsers that signed in once and never came back,
+// without touching the phone that was used this morning.
+func (s *Server) revokeIdleSessions(w http.ResponseWriter, r *http.Request) {
+	a := actorOf(r)
+	if a.User == "" {
+		jsonErr(w, 403, "only a signed-in user may do that")
+		return
+	}
+	hours := 24
+	if h := r.URL.Query().Get("hours"); h != "" {
+		n, err := strconv.Atoi(h)
+		if err != nil || n < 1 || n > 24*365 {
+			jsonErr(w, 400, "hours is a whole number from 1 to 8760")
+			return
+		}
+		hours = n
+	}
+	n := s.sessions.RevokeIdle(a.User, a.token, time.Duration(hours)*time.Hour)
+	log.Printf("%d idle session(s) of %q revoked (idle > %dh, by %s)", n, a.User, hours, clientIP(r))
+	jsonOK(w, 200, map[string]int{"revoked": n})
+}
+
 func (s *Server) revokeOtherSessions(w http.ResponseWriter, r *http.Request) {
 	a := actorOf(r)
 	if a.User == "" {

internal/auth/auth.go

@@ -28,6 +28,10 @@ const (
 	argonKeyLen  = 32
 
 	SessionTTL = 30 * 24 * time.Hour
+	// SessionIdle is how long a session may go unused before it is dropped, whatever its
+	// expiry says. Every script, curl and headless browser that signs in leaves a session;
+	// a phone that is used keeps its own alive by being used.
+	SessionIdle = 7 * 24 * time.Hour
 )
 
 func HashPassword(pw string) (string, error) {
@@ -189,12 +193,26 @@ func NewSessions(st *store.Store) *Sessions {
 func pruneExpired(state *store.State) {
 	now := time.Now()
 	for tok, ses := range state.Sessions {
-		if ses.Expires.Before(now) {
+		if !live(ses, now) {
 			delete(state.Sessions, tok)
 		}
 	}
 }
 
+// live is whether a session still counts: unexpired, and used within SessionIdle. A
+// session from before visits were recorded is judged by its creation, or failing that by
+// its expiry alone.
+func live(ses store.Session, now time.Time) bool {
+	if !ses.Expires.After(now) {
+		return false
+	}
+	seen := ses.LastSeen
+	if seen.IsZero() {
+		seen = ses.Created
+	}
+	return seen.IsZero() || now.Sub(seen) <= SessionIdle
+}
+
 func randomHex(n int) (string, error) {
 	b := make([]byte, n)
 	if _, err := rand.Read(b); err != nil {
@@ -234,7 +252,7 @@ func (s *Sessions) Lookup(tok, ip string) (store.Session, bool) {
 	ok, touch := false, false
 	s.st.View(func(state *store.State) {
 		found, have := state.Sessions[tok]
-		if have && found.Expires.After(time.Now()) {
+		if have && live(found, time.Now()) {
 			ses, ok = found, true
 			touch = time.Until(found.Expires) < SessionTTL-time.Hour || time.Since(found.LastSeen) > time.Hour
 		}
@@ -264,7 +282,7 @@ func (s *Sessions) List(user string) []store.Session {
 	s.st.View(func(state *store.State) {
 		now := time.Now()
 		for _, ses := range state.Sessions {
-			if ses.User == user && ses.Expires.After(now) {
+			if ses.User == user && live(ses, now) {
 				out = append(out, ses)
 			}
 		}
@@ -279,7 +297,7 @@ func (s *Sessions) Count() map[string]int {
 	s.st.View(func(state *store.State) {
 		now := time.Now()
 		for _, ses := range state.Sessions {
-			if ses.Expires.After(now) {
+			if live(ses, now) {
 				n[ses.User]++
 			}
 		}
@@ -315,6 +333,26 @@ func (s *Sessions) RevokeOthers(user, keep string) int {
 	return n
 }
 
+// RevokeIdle ends every session of user not seen for longer than idle, except the one
+// holding keep. Returns how many.
+func (s *Sessions) RevokeIdle(user, keep string, idle time.Duration) int {
+	n := 0
+	now := time.Now()
+	_ = s.st.Update(func(state *store.State) {
+		for tok, ses := range state.Sessions {
+			seen := ses.LastSeen
+			if seen.IsZero() {
+				seen = ses.Created
+			}
+			if ses.User == user && tok != keep && now.Sub(seen) > idle {
+				delete(state.Sessions, tok)
+				n++
+			}
+		}
+	})
+	return n
+}
+
 // RevokeUser ends every session of user (the account is going away).
 func (s *Sessions) RevokeUser(user string) { s.RevokeOthers(user, "") }
 

internal/store/store.go

@@ -68,9 +68,13 @@ type State struct {
 	// Mounts remembers where a container's bind mounts pointed, so a stack deployed by an
 	// orchestrator that has since been removed can still be found on disk. See
 	// internal/api/stacks.go.
-	Mounts     []RememberedMount `json:"mounts,omitempty"`
-	SamplerMs  int               `json:"sampler_ms,omitempty"`  // how often this machine samples; the hub keeps every machine on the console's refresh rate
-	HistorySec int               `json:"history_sec,omitempty"` // how far back the graphs reach; the hub keeps every machine on the same one
+	Mounts []RememberedMount `json:"mounts,omitempty"`
+	// KVMCookies is each KVM's own login, as the cookies its page set in a browser: kept so
+	// the next browser — or this one after it has forgotten them — is signed into the device
+	// already. See internal/api/kvm.go.
+	KVMCookies map[string]map[string]string `json:"kvm_cookies,omitempty"`
+	SamplerMs  int                          `json:"sampler_ms,omitempty"`  // how often this machine samples; the hub keeps every machine on the console's refresh rate
+	HistorySec int                          `json:"history_sec,omitempty"` // how far back the graphs reach; the hub keeps every machine on the same one
 }
 
 // UserState returns the prefs of an account, making an empty one if needed.