Merge branch 'main' into feature/mobile-detection-message

Detect mobile viewport (window.innerWidth < 768) at startup and show a
centered 'Not yet available on mobile' message instead of the full
monitoring UI. All polling, gateway detection, and network requests are
skipped entirely on mobile viewports.

Desktop behavior is completely unchanged — the mobile check is the very
first thing in init() and returns early before any other setup runs.

.gitignore

@@ -1,27 +1,4 @@
-# OS
-.DS_Store
-Thumbs.db
-
-# Editors
-*.swp
-*.swo
-*~
-*.bak
-.idea/
-.vscode/
-*.sublime-*
-
-# Node
 node_modules/
-
-# Environment / secrets
-.env
-.env.*
-*.pem
-*.key
-
-# Build output
 dist/
-
+.DS_Store
-# Logs
 *.log

Dockerfile

@@ -3,12 +3,9 @@ FROM node@sha256:e4bf2a82ad0a4037d28035ae71529873c069b13eb0455466ae0bc13363826e3
 WORKDIR /app
 COPY package.json yarn.lock ./
 RUN yarn install --frozen-lockfile
-RUN apk add --no-cache git make
+RUN apk add --no-cache git
 COPY . .
-# make check runs script/check (test + lint + fmt-check); its test step
+RUN yarn build
-# is the production yarn build, so this both produces dist/ and gates the
-# image on lint/fmt-check/test regressions, not merely a broken build.
-RUN make check
 
 # nginx:stable-alpine as of 2026-02-22
 FROM nginx@sha256:15e96e59aa3b0aada3a121296e3bce117721f42d88f5f64217ef4b18f458c6ab

Dockerfile.backend

@@ -1,50 +1,25 @@
-# Lint stage — fast feedback on formatting and lint issues. The
-# golangci/golangci-lint image ships Go, gofmt, make and the linter, so
-# nothing is installed here.
-# golangci/golangci-lint:v2.7.2 (2026-08-09)
-FROM golangci/golangci-lint@sha256:5d6d5c70a61f1356adfd9dd6316ce286799fefc9d743421356ff1b00842368ba AS lint
-
-WORKDIR /src
-COPY backend/go.mod backend/go.sum ./
-RUN go mod download
-COPY backend/ .
-RUN make fmt-check
-RUN make lint
-
-# Build stage
 # golang:1.25-alpine (2026-02-27)
 FROM golang:1.25-alpine@sha256:f6751d823c26342f9506c03797d2527668d095b0a15f1862cddb4d927a7a4ced AS builder
 
-RUN apk add --no-cache make
+RUN apk add --no-cache git make gcc musl-dev
 
-WORKDIR /src
+# golangci-lint v2.7.2 (2026-02-27)
-
+RUN CGO_ENABLED=0 go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@9f61b0f53f80672872fced07b6874397c3ed197b
-# Force BuildKit to run the lint stage before proceeding. BuildKit runs
-# stages in parallel by default; without this no-op copy a lint failure
-# would not gate compilation.
-COPY --from=lint /src/go.sum /dev/null
 
+WORKDIR /repo/backend
 COPY backend/go.mod backend/go.sum ./
 RUN go mod download
+COPY .git /repo/.git
 COPY backend/ .
 
-RUN make test
+RUN make check
+RUN make build
 
-# The build is driven through the Makefile so there is exactly one
-# definition of the build command; it expands to
-# CGO_ENABLED=0 go build -trimpath -ldflags "-s -w -X main.Version=... -X main.Buildarch=..."
-# VERSION is handed over in the environment rather than as a make
-# variable so it still reaches the build if the target is ever turned
-# into a shim around a script.
-ARG VERSION=dev
-RUN VERSION="${VERSION}" make build
-
-# Runtime stage
 # alpine:3.23 (2026-02-27)
 FROM alpine:3.23@sha256:25109184c71bdad752c8312a8623239686a9a2071e8825f20acb8f2198c3f659
 
 RUN apk add --no-cache ca-certificates
-COPY --from=builder /src/netwatch-server /usr/local/bin/netwatch-server
+COPY --from=builder /repo/backend/netwatch-server /usr/local/bin/netwatch-server
 
 EXPOSE 8080
 ENTRYPOINT ["netwatch-server"]

README.md

@@ -125,6 +125,9 @@ dist/
   false outage)
 - Clickable service URLs
 - Canvas-based sparkline rendering with devicePixelRatio scaling
+- Mobile detection: viewports narrower than 768px show a friendly "not yet
+  available on mobile" message instead of the monitoring UI (no polling or
+  network requests on mobile)
 - Zero runtime dependencies: all resources bundled into build artifacts
 
 ## Deployment
@@ -148,6 +151,8 @@ properties.
 
 ## Limitations
 
+- **Mobile**: Viewports below 768px wide show a static "not yet available"
+  message. The full monitoring UI requires a desktop-width browser.
 - **CORS**: Some hosts may block cross-origin HEAD requests. The app uses
   `no-cors` mode which allows the request but provides opaque responses. Latency
   is still measurable based on request timing.

TODO.md

@@ -22,37 +22,6 @@ files, so merging it also closes most compliance gaps.
 
 # Completed Steps
 
-- 2026-09-21: shutdown lifecycle correctness. The process now shuts down through
-  fx instead of `os.Exit`, so every component's `OnStop` runs and buffered
-  reports are flushed to disk on `SIGTERM` — previously a full flush window of
-  telemetry was silently lost on every restart. The `http.Server` is now built
-  before its serving goroutine starts, so shutdown can no longer race or
-  nil-deref it; a listen failure exits non-zero via `fx.Shutdowner`; `reportbuf`
-  `OnStop` is idempotent; and `writeTimeout` now exceeds the chi per-request
-  budget so that budget is actually reachable. Dead `startupTime`, `exitCode`,
-  and `cancelFunc` fields were removed
-- 2026-09-21: backend HTTP hardening (issue #19): added `ReadHeaderTimeout` and
-  `IdleTimeout` to the server, a `SecurityHeaders` middleware (HSTS, tight CSP,
-  frame/sniff/referrer/permissions headers) registered before CORS, and
-  trusted-proxy client IP resolution honouring `X-Forwarded-For` / `X-Real-IP`
-  only from a `TRUSTED_PROXIES` allowlist (loopback plus RFC1918 by default)
-- 2026-08-10: every interactive control now meets the 44x44 CSS px minimum tap
-  target (`.pin-btn`, `#interval-select`, the debug-log label and, on narrow
-  viewports, `#pause-btn`). The pin button's hit area grows via matching
-  negative margins, so its layout footprint and row density are unchanged
-- 2026-08-10: per-host status line wraps below the 768px breakpoint instead of
-  forcing horizontal page scroll at 320px
-- 2026-08-09: `Dockerfile.backend` reworked to the mandated Go multistage
-  lint-stage pattern: separate `lint` stage on the hash-pinned
-  `golangci/golangci-lint` image, `COPY --from=lint` stage dependency,
-  `CGO_ENABLED=0` static build driven by `ARG VERSION`, and no more `COPY .git`
-- 2026-08-09: dotfile compliance — lifted `backend/.editorconfig` to the repo
-  root so `root = true` covers the frontend too, and replaced `.gitignore` with
-  the org model (OS, editor, node, and environment/secrets sections) plus this
-  repo's `dist/` and `*.log`. `.env`, `.env.*`, `*.pem`, and `*.key` are now
-  ignored repo-wide, not just under `backend/`. Excluding `.git` from
-  `.dockerignore` stays deferred: both images read git metadata at build time
-  (`COPY .git` in `Dockerfile.backend`, `git rev-parse` in `vite.config.js`)
 - 2026-07-07 Adopted scripts-to-rule-them-all: `script/` entrypoints, Makefile
   shims, README Entrypoints section
 - 2026-02-27: backend with buffered zstd-compressed report storage; CI workflow

backend/Makefile

@@ -1,22 +1,25 @@
-# VERSION is overridable (the Dockerfile passes its ARG VERSION in) and
+UNAME_S := $(shell uname -s)
-# degrades to "dev" when git is unavailable or there is no .git — the
+VERSION := $(shell git describe --always --dirty)
-# build must not depend on the repository history being in the build
-# context.
-VERSION ?= $(shell { git describe --always --dirty; } 2>/dev/null || echo dev)
 BUILDARCH := $(shell uname -m)
 BINARY := netwatch-server
 
-GOLDFLAGS += -s -w
 GOLDFLAGS += -X main.Version=$(VERSION)
 GOLDFLAGS += -X main.Buildarch=$(BUILDARCH)
 
+ifeq ($(UNAME_S),Darwin)
+	GOFLAGS := -ldflags "$(GOLDFLAGS)"
+else
+	GOFLAGS = -ldflags "-linkmode external -extldflags -static $(GOLDFLAGS)"
+endif
+
 .PHONY: all build test lint fmt fmt-check check docker hooks run clean
 
 all: build
 
-build:
+build: ./$(BINARY)
-	CGO_ENABLED=0 go build -trimpath -ldflags "$(GOLDFLAGS)" \
+
-		-o ./$(BINARY) ./cmd/netwatch-server/
+./$(BINARY): $(shell find . -name '*.go' -type f) go.mod go.sum
+	go build -o $@ $(GOFLAGS) ./cmd/netwatch-server/
 
 test:
 	timeout 30 go test ./...

backend/README.md

@@ -42,17 +42,11 @@ Internal packages in `internal/` follow standard Go project layout:
 
 ### Configuration
 
-| Variable          | Default              | Description                                                                                              |
+| Variable   | Default            | Description                       |
-| ----------------- | -------------------- | -------------------------------------------------------------------------------------------------------- |
+| ---------- | ------------------ | --------------------------------- |
-| `PORT`            | `8080`               | HTTP listen port                                                                                         |
+| `PORT`     | `8080`             | HTTP listen port                  |
-| `DATA_DIR`        | `./data/reports`     | Directory for compressed reports                                                                         |
+| `DATA_DIR` | `./data/reports`   | Directory for compressed reports  |
-| `DEBUG`           | `false`              | Enable debug logging                                                                                     |
+| `DEBUG`    | `false`            | Enable debug logging              |
-| `TRUSTED_PROXIES` | loopback + RFC1918   | Comma-separated CIDRs whose `X-Forwarded-For` / `X-Real-IP` headers are trusted for client IP resolution |
-
-`TRUSTED_PROXIES` defaults to `127.0.0.1/32,::1/128,10.0.0.0/8,172.16.0.0/12,192.168.0.0/16`.
-The loopback entries cover the reverse proxy that shares the container; the
-RFC1918 ranges match `nginx.conf`. A request whose direct peer is outside this
-set has its forwarded headers ignored, and the direct peer is logged instead.
 
 ### Report storage
 

backend/internal/config/config.go

@@ -5,7 +5,6 @@ package config
 import (
 	"errors"
 	"log/slog"
-	"strings"
 
 	"sneak.berlin/go/netwatch/internal/globals"
 	"sneak.berlin/go/netwatch/internal/logger"
@@ -15,14 +14,6 @@ import (
 	"go.uber.org/fx"
 )
 
-// defaultTrustedProxies lists the networks whose forwarded
-// headers are honoured by default. It covers the RFC1918
-// ranges (to match nginx.conf) plus IPv4 and IPv6 loopback,
-// because the reverse proxy shares the container and reaches
-// the backend over loopback.
-const defaultTrustedProxies = "127.0.0.1/32,::1/128," +
-	"10.0.0.0/8,172.16.0.0/12,192.168.0.0/16"
-
 // Params defines the dependencies for Config.
 type Params struct {
 	fx.In
@@ -39,7 +30,6 @@ type Config struct {
 	MetricsUsername string
 	Port            int
 	SentryDSN       string
-	TrustedProxies  []string
 	log             *slog.Logger
 	params          *Params
 }
@@ -66,7 +56,6 @@ func New(
 	viper.SetDefault("SENTRY_DSN", "")
 	viper.SetDefault("METRICS_USERNAME", "")
 	viper.SetDefault("METRICS_PASSWORD", "")
-	viper.SetDefault("TRUSTED_PROXIES", defaultTrustedProxies)
 
 	err := viper.ReadInConfig()
 	if err != nil {
@@ -84,7 +73,6 @@ func New(
 		MetricsUsername: viper.GetString("METRICS_USERNAME"),
 		Port:            viper.GetInt("PORT"),
 		SentryDSN:       viper.GetString("SENTRY_DSN"),
-		TrustedProxies:  splitList(viper.GetString("TRUSTED_PROXIES")),
 		log:             log,
 		params:          &params,
 	}
@@ -96,19 +84,3 @@ func New(
 
 	return s, nil
 }
-
-// splitList turns a comma-separated setting into a trimmed
-// slice, dropping empty entries.
-func splitList(raw string) []string {
-	parts := strings.Split(raw, ",")
-
-	out := make([]string, 0, len(parts))
-	for _, p := range parts {
-		p = strings.TrimSpace(p)
-		if p != "" {
-			out = append(out, p)
-		}
-	}
-
-	return out
-}

backend/internal/middleware/export_test.go

@@ -1,21 +0,0 @@
-package middleware
-
-import (
-	"net/http"
-	"net/netip"
-)
-
-// Test-only wrappers exposing unexported helpers to the
-// external middleware_test package.
-
-func ClientIP(
-	remoteAddr string,
-	header http.Header,
-	trusted []netip.Prefix,
-) string {
-	return clientIP(remoteAddr, header, trusted)
-}
-
-func ParseTrustedProxies(cidrs []string) ([]netip.Prefix, error) {
-	return parseTrustedProxies(cidrs)
-}

backend/internal/middleware/middleware.go

@@ -3,12 +3,9 @@
 package middleware
 
 import (
-	"fmt"
 	"log/slog"
 	"net"
 	"net/http"
-	"net/netip"
-	"strings"
 	"time"
 
 	"sneak.berlin/go/netwatch/internal/config"
@@ -22,15 +19,6 @@ import (
 
 const corsMaxAgeSec = 300
 
-// Security header values. The backend is a JSON API with no
-// HTML surface, so the CSP forbids every resource type and
-// framing outright.
-const (
-	hstsValue              = "max-age=31536000; includeSubDomains"
-	cspValue               = "default-src 'none'; frame-ancestors 'none'"
-	permissionsPolicyValue = "camera=(), microphone=(), geolocation=()"
-)
-
 // Params defines the dependencies for Middleware.
 type Params struct {
 	fx.In
@@ -42,9 +30,8 @@ type Params struct {
 
 // Middleware holds shared state for middleware factories.
 type Middleware struct {
-	log            *slog.Logger
+	log    *slog.Logger
-	params         *Params
+	params *Params
-	trustedProxies []netip.Prefix
 }
 
 // New creates a Middleware instance.
@@ -52,38 +39,13 @@ func New(
 	_ fx.Lifecycle,
 	params Params,
 ) (*Middleware, error) {
-	trusted, err := parseTrustedProxies(params.Config.TrustedProxies)
-	if err != nil {
-		return nil, err
-	}
-
 	s := new(Middleware)
 	s.params = &params
 	s.log = params.Logger.Get()
-	s.trustedProxies = trusted
 
 	return s, nil
 }
 
-// parseTrustedProxies converts CIDR strings into prefixes,
-// failing fast on any malformed entry.
-func parseTrustedProxies(cidrs []string) ([]netip.Prefix, error) {
-	prefixes := make([]netip.Prefix, 0, len(cidrs))
-
-	for _, cidr := range cidrs {
-		prefix, err := netip.ParsePrefix(cidr)
-		if err != nil {
-			return nil, fmt.Errorf(
-				"trusted proxy %q: %w", cidr, err,
-			)
-		}
-
-		prefixes = append(prefixes, prefix.Masked())
-	}
-
-	return prefixes, nil
-}
-
 type loggingResponseWriter struct {
 	http.ResponseWriter
 
@@ -110,70 +72,6 @@ func ipFromHostPort(hostPort string) string {
 	return host
 }
 
-// clientIP resolves the caller's address. X-Forwarded-For and
-// X-Real-IP are honoured only when the direct peer is a
-// trusted proxy; otherwise the direct peer is returned so a
-// spoofed header cannot forge the logged address.
-func clientIP(
-	remoteAddr string,
-	header http.Header,
-	trusted []netip.Prefix,
-) string {
-	peer := ipFromHostPort(remoteAddr)
-
-	if !addrInAny(peer, trusted) {
-		return peer
-	}
-
-	if xff := firstForwardedFor(header.Get("X-Forwarded-For")); xff != "" {
-		return xff
-	}
-
-	if xr := strings.TrimSpace(header.Get("X-Real-IP")); validIP(xr) {
-		return xr
-	}
-
-	return peer
-}
-
-// firstForwardedFor returns the left-most valid address in an
-// X-Forwarded-For list (the original client), or "" if none.
-func firstForwardedFor(value string) string {
-	for part := range strings.SplitSeq(value, ",") {
-		candidate := strings.TrimSpace(part)
-		if validIP(candidate) {
-			return candidate
-		}
-	}
-
-	return ""
-}
-
-func validIP(s string) bool {
-	_, err := netip.ParseAddr(s)
-
-	return err == nil
-}
-
-// addrInAny reports whether s parses as an address contained
-// in any of the trusted prefixes.
-func addrInAny(s string, trusted []netip.Prefix) bool {
-	addr, err := netip.ParseAddr(s)
-	if err != nil {
-		return false
-	}
-
-	addr = addr.Unmap()
-
-	for _, prefix := range trusted {
-		if prefix.Contains(addr) {
-			return true
-		}
-	}
-
-	return false
-}
-
 // Logging returns middleware that logs each request with
 // timing, status code, and client information.
 func (s *Middleware) Logging() func(http.Handler) http.Handler {
@@ -198,11 +96,7 @@ func (s *Middleware) Logging() func(http.Handler) http.Handler {
 						"referer", r.Referer(),
 						"proto", r.Proto,
 						"remote_ip",
-						clientIP(
+						ipFromHostPort(r.RemoteAddr),
-							r.RemoteAddr,
-							r.Header,
-							s.trustedProxies,
-						),
 						"status", lrw.statusCode,
 						"latency_ms",
 						latency.Milliseconds(),
@@ -215,27 +109,6 @@ func (s *Middleware) Logging() func(http.Handler) http.Handler {
 	}
 }
 
-// SecurityHeaders returns middleware that sets response
-// security headers. It runs before CORS so the headers are
-// present on preflight responses the CORS handler writes.
-func (s *Middleware) SecurityHeaders() func(http.Handler) http.Handler {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(
-			func(w http.ResponseWriter, r *http.Request) {
-				h := w.Header()
-				h.Set("Strict-Transport-Security", hstsValue)
-				h.Set("Content-Security-Policy", cspValue)
-				h.Set("X-Frame-Options", "DENY")
-				h.Set("X-Content-Type-Options", "nosniff")
-				h.Set("Referrer-Policy", "no-referrer")
-				h.Set("Permissions-Policy", permissionsPolicyValue)
-
-				next.ServeHTTP(w, r)
-			},
-		)
-	}
-}
-
 // CORS returns middleware that adds permissive CORS headers.
 func (s *Middleware) CORS() func(http.Handler) http.Handler {
 	return cors.Handler(cors.Options{

backend/internal/middleware/middleware_test.go

@@ -1,139 +0,0 @@
-package middleware_test
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"net/netip"
-	"testing"
-
-	"sneak.berlin/go/netwatch/internal/middleware"
-)
-
-func mustPrefixes(t *testing.T, cidrs ...string) []netip.Prefix {
-	t.Helper()
-
-	prefixes, err := middleware.ParseTrustedProxies(cidrs)
-	if err != nil {
-		t.Fatalf("ParseTrustedProxies(%v): %v", cidrs, err)
-	}
-
-	return prefixes
-}
-
-func TestParseTrustedProxiesRejectsMalformed(t *testing.T) {
-	t.Parallel()
-
-	_, err := middleware.ParseTrustedProxies([]string{"not-a-cidr"})
-	if err == nil {
-		t.Fatal("expected error for malformed CIDR, got nil")
-	}
-}
-
-type clientIPCase struct {
-	name       string
-	remoteAddr string
-	xff        string
-	xRealIP    string
-	want       string
-}
-
-func clientIPCases() []clientIPCase {
-	return []clientIPCase{
-		{
-			name:       "trusted proxy uses forwarded-for",
-			remoteAddr: "127.0.0.1:5000",
-			xff:        "203.0.113.7",
-			want:       "203.0.113.7",
-		},
-		{
-			name:       "trusted proxy uses left-most of chain",
-			remoteAddr: "10.1.2.3:5000",
-			xff:        "203.0.113.7, 10.1.2.3",
-			want:       "203.0.113.7",
-		},
-		{
-			name:       "trusted proxy falls back to x-real-ip",
-			remoteAddr: "127.0.0.1:5000",
-			xRealIP:    "203.0.113.9",
-			want:       "203.0.113.9",
-		},
-		{
-			name:       "untrusted peer ignores forwarded-for",
-			remoteAddr: "198.51.100.4:5000",
-			xff:        "203.0.113.7",
-			want:       "198.51.100.4",
-		},
-		{
-			name:       "untrusted peer ignores x-real-ip",
-			remoteAddr: "198.51.100.4:5000",
-			xRealIP:    "203.0.113.9",
-			want:       "198.51.100.4",
-		},
-		{
-			name:       "trusted proxy with no headers uses peer",
-			remoteAddr: "10.1.2.3:5000",
-			want:       "10.1.2.3",
-		},
-		{
-			name:       "trusted proxy with garbage header uses peer",
-			remoteAddr: "127.0.0.1:5000",
-			xff:        "not-an-ip",
-			want:       "127.0.0.1",
-		},
-	}
-}
-
-func TestClientIP(t *testing.T) {
-	t.Parallel()
-
-	trusted := mustPrefixes(t, "127.0.0.1/32", "::1/128", "10.0.0.0/8")
-
-	for _, tc := range clientIPCases() {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			header := http.Header{}
-			if tc.xff != "" {
-				header.Set("X-Forwarded-For", tc.xff)
-			}
-
-			if tc.xRealIP != "" {
-				header.Set("X-Real-IP", tc.xRealIP)
-			}
-
-			got := middleware.ClientIP(tc.remoteAddr, header, trusted)
-			if got != tc.want {
-				t.Errorf("ClientIP() = %q, want %q", got, tc.want)
-			}
-		})
-	}
-}
-
-func TestSecurityHeaders(t *testing.T) {
-	t.Parallel()
-
-	handler := (&middleware.Middleware{}).SecurityHeaders()(
-		http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-			w.WriteHeader(http.StatusOK)
-		}),
-	)
-
-	rec := httptest.NewRecorder()
-	req := httptest.NewRequest(http.MethodGet, "/", http.NoBody)
-	handler.ServeHTTP(rec, req)
-
-	want := map[string]string{
-		"Strict-Transport-Security": "max-age=31536000; includeSubDomains",
-		"Content-Security-Policy":   "default-src 'none'; frame-ancestors 'none'",
-		"X-Frame-Options":           "DENY",
-		"X-Content-Type-Options":    "nosniff",
-		"Referrer-Policy":           "no-referrer",
-		"Permissions-Policy":        "camera=(), microphone=(), geolocation=()",
-	}
-
-	for name, value := range want {
-		if got := rec.Header().Get(name); got != value {
-			t.Errorf("header %s = %q, want %q", name, got, value)
-		}
-	}
-}

backend/internal/reportbuf/reportbuf.go

@@ -40,12 +40,11 @@ type Params struct {
 // Buffer accumulates JSON lines in memory and flushes them
 // to zstd-compressed files on disk.
 type Buffer struct {
-	buf      bytes.Buffer
+	buf     bytes.Buffer
-	dataDir  string
+	dataDir string
-	done     chan struct{}
+	done    chan struct{}
-	log      *slog.Logger
+	log     *slog.Logger
-	mu       sync.Mutex
+	mu      sync.Mutex
-	stopOnce sync.Once
 }
 
 // New creates a Buffer and registers lifecycle hooks to
@@ -77,13 +76,8 @@ func New(
 			return nil
 		},
 		OnStop: func(_ context.Context) error {
-			// stopOnce makes OnStop idempotent: a second
+			close(b.done)
-			// invocation must not close an already-closed channel
+			b.flushLocked()
-			// (which would panic) or flush again.
-			b.stopOnce.Do(func() {
-				close(b.done)
-				b.flushLocked()
-			})
 
 			return nil
 		},

backend/internal/reportbuf/reportbuf_test.go

@@ -1,77 +1,13 @@
 package reportbuf_test
 
 import (
-	"os"
-	"strings"
 	"testing"
 
-	"sneak.berlin/go/netwatch/internal/config"
+	_ "sneak.berlin/go/netwatch/internal/reportbuf"
-	"sneak.berlin/go/netwatch/internal/globals"
-	"sneak.berlin/go/netwatch/internal/logger"
-	"sneak.berlin/go/netwatch/internal/reportbuf"
-
-	"go.uber.org/fx"
-	"go.uber.org/fx/fxtest"
 )
 
-// TestFlushOnShutdown proves the flush-on-shutdown path: a
+func TestImport(t *testing.T) {
-// report appended after start but before the periodic flush
+	t.Parallel()
-// window must reach disk when the fx lifecycle stops. This is
+	// Compilation check — verifies the package parses
-// the exact case that silent data loss on restart used to
+	// and all imports resolve.
-// destroy.
-func TestFlushOnShutdown(t *testing.T) {
-	dir := t.TempDir()
-	t.Setenv("DATA_DIR", dir)
-
-	var buf *reportbuf.Buffer
-
-	app := fxtest.New(t,
-		fx.Provide(
-			globals.New,
-			logger.New,
-			config.New,
-			reportbuf.New,
-		),
-		fx.Populate(&buf),
-	)
-
-	app.RequireStart()
-
-	err := buf.Append(map[string]string{"probe": "shutdown"})
-	if err != nil {
-		t.Fatalf("append report: %v", err)
-	}
-
-	// RequireStop runs the reportbuf OnStop hook, which is the
-	// only code path that flushes buffered reports on shutdown.
-	app.RequireStop()
-
-	if !hasReportFile(t, dir) {
-		t.Fatal("no report file on disk after shutdown; " +
-			"the buffered report was lost")
-	}
-}
-
-func hasReportFile(t *testing.T, dir string) bool {
-	t.Helper()
-
-	entries, err := os.ReadDir(dir)
-	if err != nil {
-		t.Fatalf("read data dir: %v", err)
-	}
-
-	for _, e := range entries {
-		if strings.HasSuffix(e.Name(), ".jsonl.zst") {
-			info, statErr := e.Info()
-			if statErr != nil {
-				t.Fatalf("stat %s: %v", e.Name(), statErr)
-			}
-
-			if info.Size() > 0 {
-				return true
-			}
-		}
-	}
-
-	return false
 }

backend/internal/server/http.go

@@ -5,62 +5,39 @@ import (
 	"fmt"
 	"net/http"
 	"time"
-
-	"go.uber.org/fx"
 )
 
 const (
-	readTimeout       = 10 * time.Second
+	readTimeout    = 10 * time.Second
-	readHeaderTimeout = 5 * time.Second
+	writeTimeout   = 10 * time.Second
-	idleTimeout       = 60 * time.Second
+	maxHeaderBytes = 1 << 20 // 1 MiB
-	maxHeaderBytes    = 1 << 20 // 1 MiB
-
-	// requestTimeout (routes.go) is the single per-request
-	// processing budget, enforced by chi's middleware.Timeout.
-	// writeTimeout must exceed that budget so a handler can write
-	// its 503 when the chi timeout fires; if it were shorter the
-	// server would abort the write first and the chi budget would
-	// be unreachable dead configuration.
-	writeTimeout = requestTimeout + 5*time.Second
 )
 
-// newHTTPServer constructs the http.Server. It performs no I/O
+func (s *Server) serveUntilShutdown() {
-// and does not start listening.
-func (s *Server) newHTTPServer() *http.Server {
 	listenAddr := fmt.Sprintf(":%d", s.params.Config.Port)
 
-	return &http.Server{
+	s.httpServer = &http.Server{
-		Addr:              listenAddr,
+		Addr:           listenAddr,
-		Handler:           s,
+		Handler:        s,
-		MaxHeaderBytes:    maxHeaderBytes,
+		MaxHeaderBytes: maxHeaderBytes,
-		ReadTimeout:       readTimeout,
+		ReadTimeout:    readTimeout,
-		ReadHeaderTimeout: readHeaderTimeout,
+		WriteTimeout:   writeTimeout,
-		WriteTimeout:      writeTimeout,
-		IdleTimeout:       idleTimeout,
 	}
-}
 
-// listenAndServe runs the listener until the server is shut
+	s.SetupRoutes()
-// down. A genuine listen failure (not the expected
+
-// ErrServerClosed from a clean shutdown) requests process
-// shutdown through fx with a non-zero exit code, so the failure
-// is visible to any supervisor.
-func (s *Server) listenAndServe() {
 	s.log.Info("http begin listen",
-		"listenaddr", s.httpServer.Addr,
+		"listenaddr", listenAddr,
 		"version", s.params.Globals.Version,
 		"buildarch", s.params.Globals.Buildarch,
 	)
 
 	err := s.httpServer.ListenAndServe()
-	if err == nil || errors.Is(err, http.ErrServerClosed) {
+	if err != nil && !errors.Is(err, http.ErrServerClosed) {
-		return
+		s.log.Error("listen error", "error", err)
-	}
 
-	s.log.Error("listen error", "error", err)
+		if s.cancelFunc != nil {
-
+			s.cancelFunc()
-	shutdownErr := s.shutdowner.Shutdown(fx.ExitCode(1))
+		}
-	if shutdownErr != nil {
-		s.log.Error("request shutdown failed", "error", shutdownErr)
 	}
 }

backend/internal/server/routes.go

@@ -17,7 +17,6 @@ func (s *Server) SetupRoutes() {
 	s.router.Use(middleware.Recoverer)
 	s.router.Use(middleware.RequestID)
 	s.router.Use(s.mw.Logging())
-	s.router.Use(s.mw.SecurityHeaders())
 	s.router.Use(s.mw.CORS())
 	s.router.Use(middleware.Timeout(requestTimeout))
 

backend/internal/server/server.go

@@ -1,14 +1,16 @@
 // Package server provides the HTTP server lifecycle,
-// including startup, routing, and graceful shutdown. The
+// including startup, routing, signal handling, and graceful
-// process lifetime is owned by fx: shutdown is requested
+// shutdown.
-// through fx.Shutdowner so every component's OnStop hook runs
-// in dependency order.
 package server
 
 import (
 	"context"
 	"log/slog"
 	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
 
 	"sneak.berlin/go/netwatch/internal/config"
 	"sneak.berlin/go/netwatch/internal/globals"
@@ -29,18 +31,19 @@ type Params struct {
 	Handlers   *handlers.Handlers
 	Logger     *logger.Logger
 	Middleware *middleware.Middleware
-	Shutdowner fx.Shutdowner
 }
 
 // Server is the top-level HTTP server orchestrator.
 type Server struct {
-	h          *handlers.Handlers
+	cancelFunc  context.CancelFunc
-	httpServer *http.Server
+	exitCode    int
-	log        *slog.Logger
+	h           *handlers.Handlers
-	mw         *middleware.Middleware
+	httpServer  *http.Server
-	params     Params
+	log         *slog.Logger
-	router     *chi.Mux
+	mw          *middleware.Middleware
-	shutdowner fx.Shutdowner
+	params      Params
+	router      *chi.Mux
+	startupTime time.Time
 }
 
 // New creates a Server and registers lifecycle hooks for
@@ -54,25 +57,23 @@ func New(
 	s.mw = params.Middleware
 	s.h = params.Handlers
 	s.log = params.Logger.Get()
-	s.shutdowner = params.Shutdowner
 
 	lc.Append(fx.Hook{
 		OnStart: func(_ context.Context) error {
-			// Build the router and http.Server synchronously
+			s.startupTime = time.Now().UTC()
-			// here, before spawning the serving goroutine, so
-			// httpServer is fully constructed by the time OnStop
-			// (or an early signal) can read it. fx guarantees
-			// OnStart returns before OnStop runs, so no
-			// synchronization or nil check is needed at shutdown.
-			s.SetupRoutes()
-			s.httpServer = s.newHTTPServer()
 
-			go s.listenAndServe()
+			go func() { //nolint:contextcheck // fx OnStart ctx is startup-only; run() creates its own
+				s.run()
+			}()
 
 			return nil
 		},
-		OnStop: func(ctx context.Context) error {
+		OnStop: func(_ context.Context) error {
-			return s.shutdown(ctx)
+			if s.cancelFunc != nil {
+				s.cancelFunc()
+			}
+
+			return nil
 		},
 	})
 
@@ -87,17 +88,60 @@ func (s *Server) ServeHTTP(
 	s.router.ServeHTTP(w, r)
 }
 
-// shutdown gracefully stops the HTTP server within the
+func (s *Server) run() {
-// deadline of the context fx provides for OnStop.
+	exitCode := s.serve()
-func (s *Server) shutdown(ctx context.Context) error {
+	os.Exit(exitCode)
-	err := s.httpServer.Shutdown(ctx)
+}
-	if err != nil {
-		s.log.Error("server clean shutdown failed", "error", err)
 
-		return err
+func (s *Server) serve() int {
+	var ctx context.Context //nolint:wsl // ctx must be declared before multi-assign
+
+	ctx, s.cancelFunc = context.WithCancel(
+		context.Background(),
+	)
+
+	go func() {
+		c := make(chan os.Signal, 1)
+
+		signal.Ignore(syscall.SIGPIPE)
+		signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+
+		sig := <-c
+		s.log.Info("signal received", "signal", sig)
+
+		if s.cancelFunc != nil {
+			s.cancelFunc()
+		}
+	}()
+
+	go func() {
+		s.serveUntilShutdown()
+	}()
+
+	<-ctx.Done()
+	s.cleanShutdown()
+
+	return s.exitCode
+}
+
+const shutdownTimeout = 5 * time.Second
+
+func (s *Server) cleanShutdown() {
+	s.exitCode = 0
+
+	ctxShutdown, shutdownCancel := context.WithTimeout(
+		context.Background(),
+		shutdownTimeout,
+	)
+	defer shutdownCancel()
+
+	err := s.httpServer.Shutdown(ctxShutdown)
+	if err != nil {
+		s.log.Error(
+			"server clean shutdown failed",
+			"error", err,
+		)
 	}
 
 	s.log.Info("server stopped")
-
-	return nil
 }

src/main.js

@@ -537,12 +537,6 @@ class SparklineRenderer {
 
 // --- UI Renderer -------------------------------------------------------------
 
-// The per-host status line must stay wrappable: its populated content is
-// wider than the host column at a 320px viewport, and `whitespace-nowrap`
-// here overflows the element and forces the whole document to scroll
-// horizontally.
-const STATUS_TEXT_CLASS = "status-text text-xs text-right col-span-2 mt-5";
-
 function hostRowHTML(host, index, showPin = true) {
     const pinColor = host.pinned
         ? "text-blue-500"
@@ -568,7 +562,7 @@ function hostRowHTML(host, index, showPin = true) {
             <span class="text-gray-500">---</span>
           </div>
           <a href="${host.url}" target="_blank" rel="noopener" class="text-xs text-gray-500 truncate block col-span-2 -mt-2">${host.url}</a>
-          <div class="${STATUS_TEXT_CLASS} text-gray-500" data-host="${index}">waiting...</div>
+          <div class="status-text text-xs text-gray-500 whitespace-nowrap text-right col-span-2 mt-5" data-host="${index}">waiting...</div>
         </div>
         <div class="flex-grow sparkline-container rounded overflow-hidden border border-gray-700/30">
           <canvas class="sparkline-canvas w-full" data-host="${index}" height="${CONFIG.canvasHeight}"></canvas>
@@ -677,7 +671,7 @@ function buildUI(state) {
         </p>
         <p class="mt-2"><a href="https://git.eeqj.de/sneak/netwatch/commit/${__COMMIT_FULL__}" target="_blank" rel="noopener" class="text-gray-600 hover:text-gray-400">${__COMMIT_HASH__}</a></p>
         <p class="mt-2">
-          <label class="debug-toggle-label cursor-pointer">
+          <label class="cursor-pointer">
             <input type="checkbox" id="debug-toggle" class="mr-1">
             <span>Debug log</span>
           </label>
@@ -694,26 +688,6 @@ function buildUI(state) {
 
 // --- UI Updaters -------------------------------------------------------------
 
-// Renders `min 1ms / med 2ms / avg 3ms / max 4ms`. Each label, value and
-// trailing separator is one unbreakable unit, so wrapping only ever happens
-// between stats and a wrapped line never starts with a separator.
-function statusStatsHTML(stats) {
-    return stats
-        .map(([label, value], i) => {
-            const sep =
-                i < stats.length - 1
-                    ? ` <span class="text-gray-500">/</span>`
-                    : "";
-            return (
-                `<span class="whitespace-nowrap">` +
-                `<span class="text-gray-400">${label} </span>` +
-                `<span class="${latencyClass(value, "online")}">${value}ms</span>` +
-                `${sep}</span>`
-            );
-        })
-        .join(" ");
-}
-
 function updateHostRow(host, index) {
     const latencyEl = document.querySelector(
         `.latency-value[data-host="${index}"]`,
@@ -738,22 +712,28 @@ function updateHostRow(host, index) {
     const min = host.minLatency();
     const max = host.maxLatency();
     if (host.status === "online" && avg !== null) {
-        statusEl.innerHTML = statusStatsHTML([
+        statusEl.innerHTML =
-            ["min", min],
+            `<span class="text-gray-400">min </span><span class="${latencyClass(min, "online")}">${min}ms</span>` +
-            ["med", med],
+            ` <span class="text-gray-500">/</span> ` +
-            ["avg", avg],
+            `<span class="text-gray-400">med </span><span class="${latencyClass(med, "online")}">${med}ms</span>` +
-            ["max", max],
+            ` <span class="text-gray-500">/</span> ` +
-        ]);
+            `<span class="text-gray-400">avg </span><span class="${latencyClass(avg, "online")}">${avg}ms</span>` +
-        statusEl.className = STATUS_TEXT_CLASS;
+            ` <span class="text-gray-500">/</span> ` +
+            `<span class="text-gray-400">max </span><span class="${latencyClass(max, "online")}">${max}ms</span>`;
+        statusEl.className =
+            "status-text text-xs whitespace-nowrap text-right col-span-2 mt-5";
     } else if (host.status === "offline") {
         statusEl.textContent = "unreachable";
-        statusEl.className = `${STATUS_TEXT_CLASS} text-red-400`;
+        statusEl.className =
+            "status-text text-xs text-red-400 whitespace-nowrap text-right col-span-2 mt-5";
     } else if (host.status === "error") {
         statusEl.textContent = "timeout";
-        statusEl.className = `${STATUS_TEXT_CLASS} text-orange-400`;
+        statusEl.className =
+            "status-text text-xs text-orange-400 whitespace-nowrap text-right col-span-2 mt-5";
     } else {
         statusEl.textContent = "connecting...";
-        statusEl.className = `${STATUS_TEXT_CLASS} text-gray-500`;
+        statusEl.className =
+            "status-text text-xs text-gray-500 whitespace-nowrap text-right col-span-2 mt-5";
     }
 
     SparklineRenderer.draw(canvas, host.history);
@@ -1064,7 +1044,8 @@ function greyOutUI(state) {
         }
         if (statusEl) {
             statusEl.textContent = "paused";
-            statusEl.className = `${STATUS_TEXT_CLASS} text-gray-500`;
+            statusEl.className =
+                "status-text text-xs text-gray-500 whitespace-nowrap text-right col-span-2 mt-5";
         }
         // Grey out the status dot
         const row = document.querySelector(`.host-row[data-index="${i}"]`);
@@ -1145,11 +1126,46 @@ function handleResize(state) {
     });
 }
 
+// --- Mobile Detection --------------------------------------------------------
+
+const MOBILE_BREAKPOINT = 768;
+
+function isMobileViewport() {
+    return window.innerWidth < MOBILE_BREAKPOINT;
+}
+
+function buildMobileUI() {
+    const app = document.getElementById("app");
+    app.innerHTML = `
+    <div class="mx-auto px-[5%] py-8">
+      <header class="mb-8">
+        <h1 class="text-3xl font-bold text-white"><a href="https://git.eeqj.de/sneak/netwatch" target="_blank" rel="noopener" class="underline decoration-dashed decoration-gray-500 underline-offset-4">NetWatch</a> by <a href="https://sneak.berlin" target="_blank" rel="noopener" class="text-blue-400 underline hover:text-blue-300">@sneak</a></h1>
+        <p class="text-gray-400 text-sm mt-2">Real-time network latency monitor</p>
+      </header>
+      <div class="flex items-center justify-center min-h-[60vh]">
+        <div class="bg-gray-800/70 border border-gray-700/50 rounded-lg p-8 max-w-md text-center">
+          <p class="text-4xl mb-4">📡</p>
+          <p class="text-xl font-semibold text-white mb-2">Not yet available on mobile</p>
+          <p class="text-gray-400 text-sm">NetWatch requires a wider viewport to display latency charts and monitoring data. Please visit on a desktop browser.</p>
+        </div>
+      </div>
+      <footer class="mt-8 text-center text-gray-600 text-xs">
+        <p><a href="https://git.eeqj.de/sneak/netwatch/commit/${__COMMIT_FULL__}" target="_blank" rel="noopener" class="text-gray-600 hover:text-gray-400">${__COMMIT_HASH__}</a></p>
+      </footer>
+    </div>`;
+}
+
 // --- Bootstrap ---------------------------------------------------------------
 
 async function init() {
     log.info("NetWatch starting");
 
+    if (isMobileViewport()) {
+        log.info("Mobile viewport detected — skipping monitoring");
+        buildMobileUI();
+        return;
+    }
+
     // Probe common gateway IPs to find the local router
     const gateway = await detectGateway();
     const localHosts = [LOCAL_CPE];

src/styles.css

@@ -14,38 +14,6 @@ body {
         ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace;
 }
 
-/* ---- Minimum tap targets ----------------------------------------------
-   Every interactive control is at least 44x44 CSS px (Apple HIG, WCAG 2.2
-   SC 2.5.5). Not scoped to a breakpoint or to `pointer: coarse`: a large
-   phone in landscape is above the 768px breakpoint and still a touch
-   device. */
-
-/* The button grows to 44x44 while the negative margins keep its layout
-   footprint at the 16x16 of the icon inside it, so row height and the
-   icon's position are unchanged. */
-.pin-btn {
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    width: 2.75rem;
-    height: 2.75rem;
-    margin: -0.875rem;
-}
-
-/* A select paints its own background and border, so it has to actually be
-   44 tall rather than borrow the trick above. */
-#interval-select {
-    min-height: 2.75rem;
-}
-
-/* The tappable target for #debug-toggle is the label wrapping it. */
-.debug-toggle-label {
-    display: inline-flex;
-    align-items: center;
-    justify-content: center;
-    min-height: 2.75rem;
-}
-
 .sparkline-container {
     background: linear-gradient(
         to bottom,
@@ -70,10 +38,9 @@ body {
         gap: 0.75rem;
     }
 
-    /* Pause button: smaller on mobile, but not below the tap-target floor */
+    /* Pause button: smaller on mobile */
     #pause-btn {
         padding: 0.5rem 1rem;
-        min-height: 2.75rem;
     }
 
     #pause-btn svg {