feat: add mobile-friendly HTTP 404 and 500 error pages

Add ErrorNotFound and ErrorInternal handler methods that render styled
error pages using the error.html template, with proper status codes,
responsive layout, SVG icons, and HTMX fragment support. Replace the
plain-text http.NotFound call in Dashboard with the new styled handler.

Closes leeworks-agents/gitea-mobile#131

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

internal/gitea/client.go

@@ -8,11 +8,8 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"log/slog"
-	"math"
 	"net/http"
 	"sort"
-	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -30,11 +27,6 @@ type Client struct {
 	maxConcurrent int
 	// cacheTTL controls how long cache entries remain valid.
 	cacheTTL time.Duration
-
-	// maxRetries is the maximum number of retries for rate-limited requests.
-	maxRetries int
-	// baseRetryDelay is the initial backoff delay before the first retry.
-	baseRetryDelay time.Duration
 }
 
 type cacheEntry struct {
@@ -137,102 +129,39 @@ func NewClient(baseURL string) *Client {
 		httpClient: &http.Client{
 			Timeout: 30 * time.Second,
 		},
-		cache:          make(map[string]*cacheEntry),
-		maxConcurrent:  5,
-		cacheTTL:       30 * time.Second,
-		maxRetries:     3,
-		baseRetryDelay: 1 * time.Second,
+		cache:         make(map[string]*cacheEntry),
+		maxConcurrent: 5,
+		cacheTTL:      30 * time.Second,
 	}
 }
 
 // doRequest performs an authenticated HTTP request to the Gitea API.
-// It automatically retries on HTTP 429 (rate limit) responses with
-// exponential backoff, respecting the Retry-After header when present.
 func (c *Client) doRequest(ctx context.Context, token, method, path string, body io.Reader) (*http.Response, error) {
 	url := c.baseURL + "/api/v1" + path
 
-	// Read the body once so we can replay it on retries.
-	var bodyBytes []byte
+	req, err := http.NewRequestWithContext(ctx, method, url, body)
+	if err != nil {
+		return nil, fmt.Errorf("creating request: %w", err)
+	}
+
+	req.Header.Set("Authorization", "token "+token)
+	req.Header.Set("Accept", "application/json")
 	if body != nil {
-		var err error
-		bodyBytes, err = io.ReadAll(body)
-		if err != nil {
-			return nil, fmt.Errorf("reading request body: %w", err)
-		}
+		req.Header.Set("Content-Type", "application/json")
 	}
 
-	var lastErr error
-	for attempt := 0; attempt <= c.maxRetries; attempt++ {
-		// Recreate the body reader for each attempt.
-		var reqBody io.Reader
-		if bodyBytes != nil {
-			reqBody = strings.NewReader(string(bodyBytes))
-		}
-
-		req, err := http.NewRequestWithContext(ctx, method, url, reqBody)
-		if err != nil {
-			return nil, fmt.Errorf("creating request: %w", err)
-		}
-
-		req.Header.Set("Authorization", "token "+token)
-		req.Header.Set("Accept", "application/json")
-		if bodyBytes != nil {
-			req.Header.Set("Content-Type", "application/json")
-		}
-
-		resp, err := c.httpClient.Do(req)
-		if err != nil {
-			return nil, fmt.Errorf("executing request: %w", err)
-		}
-
-		// Not rate-limited: handle normally.
-		if resp.StatusCode != http.StatusTooManyRequests {
-			if resp.StatusCode >= 400 {
-				defer resp.Body.Close()
-				respBody, _ := io.ReadAll(resp.Body)
-				return nil, fmt.Errorf("API error %d: %s", resp.StatusCode, string(respBody))
-			}
-			return resp, nil
-		}
-
-		// Rate-limited (429): close body and compute retry delay.
-		resp.Body.Close()
-
-		if attempt == c.maxRetries {
-			lastErr = fmt.Errorf("API rate limit exceeded after %d retries (429)", c.maxRetries)
-			break
-		}
-
-		delay := c.retryDelay(resp, attempt)
-		slog.Warn("rate limited by Gitea API, retrying",
-			"attempt", attempt+1,
-			"max_retries", c.maxRetries,
-			"delay", delay,
-			"path", path,
-		)
-
-		select {
-		case <-ctx.Done():
-			return nil, ctx.Err()
-		case <-time.After(delay):
-			// Continue to next attempt.
-		}
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("executing request: %w", err)
 	}
 
-	return nil, lastErr
-}
-
-// retryDelay computes the delay before the next retry attempt. It uses the
-// Retry-After header value (in seconds) if present, otherwise falls back to
-// exponential backoff: baseRetryDelay * 2^attempt.
-func (c *Client) retryDelay(resp *http.Response, attempt int) time.Duration {
-	if ra := resp.Header.Get("Retry-After"); ra != "" {
-		if seconds, err := strconv.Atoi(ra); err == nil && seconds > 0 {
-			return time.Duration(seconds) * time.Second
-		}
+	if resp.StatusCode >= 400 {
+		defer resp.Body.Close()
+		respBody, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("API error %d: %s", resp.StatusCode, string(respBody))
 	}
-	// Exponential backoff: 1s, 2s, 4s, ...
-	return c.baseRetryDelay * time.Duration(math.Pow(2, float64(attempt)))
+
+	return resp, nil
 }
 
 // getFromCache returns cached data if still valid.

internal/gitea/client_test.go

@@ -1087,161 +1087,3 @@ func TestListAllPullRequests_Pagination(t *testing.T) {
 		t.Error("page 2: HasMore should be false")
 	}
 }
-
-func TestDoRequest_RateLimitRetry(t *testing.T) {
-	attempts := 0
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		attempts++
-		if attempts <= 2 {
-			w.Header().Set("Retry-After", "0")
-			w.WriteHeader(http.StatusTooManyRequests)
-			return
-		}
-		w.WriteHeader(http.StatusOK)
-		fmt.Fprint(w, `[{"username":"test-org"}]`)
-	}))
-	defer srv.Close()
-
-	c := NewClient(srv.URL)
-	c.maxRetries = 3
-	c.baseRetryDelay = 1 * time.Millisecond // Fast for tests.
-
-	resp, err := c.doRequest(context.Background(), "test-token", "GET", "/user/orgs", nil)
-	if err != nil {
-		t.Fatalf("expected success after retries, got: %v", err)
-	}
-	resp.Body.Close()
-
-	if attempts != 3 {
-		t.Errorf("expected 3 attempts, got %d", attempts)
-	}
-}
-
-func TestDoRequest_RateLimitExhausted(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusTooManyRequests)
-	}))
-	defer srv.Close()
-
-	c := NewClient(srv.URL)
-	c.maxRetries = 2
-	c.baseRetryDelay = 1 * time.Millisecond
-
-	_, err := c.doRequest(context.Background(), "test-token", "GET", "/user/orgs", nil)
-	if err == nil {
-		t.Fatal("expected error after exhausting retries")
-	}
-	if !strings.Contains(err.Error(), "rate limit exceeded") {
-		t.Errorf("expected rate limit error, got: %v", err)
-	}
-}
-
-func TestDoRequest_RateLimitWithRetryAfterHeader(t *testing.T) {
-	attempts := 0
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		attempts++
-		if attempts == 1 {
-			w.Header().Set("Retry-After", "1")
-			w.WriteHeader(http.StatusTooManyRequests)
-			return
-		}
-		w.WriteHeader(http.StatusOK)
-		fmt.Fprint(w, `[]`)
-	}))
-	defer srv.Close()
-
-	c := NewClient(srv.URL)
-	c.maxRetries = 3
-	c.baseRetryDelay = 1 * time.Millisecond
-
-	start := time.Now()
-	resp, err := c.doRequest(context.Background(), "test-token", "GET", "/user/orgs", nil)
-	elapsed := time.Since(start)
-	if err != nil {
-		t.Fatalf("expected success, got: %v", err)
-	}
-	resp.Body.Close()
-
-	// Retry-After: 1 means 1 second delay.
-	if elapsed < 900*time.Millisecond {
-		t.Errorf("expected at least ~1s delay from Retry-After header, got %v", elapsed)
-	}
-}
-
-func TestDoRequest_RateLimitCancelledContext(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Retry-After", "60")
-		w.WriteHeader(http.StatusTooManyRequests)
-	}))
-	defer srv.Close()
-
-	c := NewClient(srv.URL)
-	c.maxRetries = 3
-	c.baseRetryDelay = 1 * time.Millisecond
-
-	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
-	defer cancel()
-
-	_, err := c.doRequest(ctx, "test-token", "GET", "/user/orgs", nil)
-	if err == nil {
-		t.Fatal("expected error from cancelled context")
-	}
-}
-
-func TestDoRequest_NonRateLimitErrorNotRetried(t *testing.T) {
-	attempts := 0
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		attempts++
-		w.WriteHeader(http.StatusForbidden)
-		fmt.Fprint(w, `{"message":"forbidden"}`)
-	}))
-	defer srv.Close()
-
-	c := NewClient(srv.URL)
-	c.maxRetries = 3
-	c.baseRetryDelay = 1 * time.Millisecond
-
-	_, err := c.doRequest(context.Background(), "test-token", "GET", "/user/orgs", nil)
-	if err == nil {
-		t.Fatal("expected error for 403")
-	}
-	if attempts != 1 {
-		t.Errorf("expected only 1 attempt for non-429 error, got %d", attempts)
-	}
-}
-
-func TestRetryDelay_WithRetryAfterHeader(t *testing.T) {
-	c := NewClient("https://example.com")
-	c.baseRetryDelay = 1 * time.Second
-
-	resp := &http.Response{Header: http.Header{}}
-	resp.Header.Set("Retry-After", "5")
-
-	delay := c.retryDelay(resp, 0)
-	if delay != 5*time.Second {
-		t.Errorf("expected 5s from Retry-After, got %v", delay)
-	}
-}
-
-func TestRetryDelay_ExponentialBackoff(t *testing.T) {
-	c := NewClient("https://example.com")
-	c.baseRetryDelay = 1 * time.Second
-
-	resp := &http.Response{Header: http.Header{}}
-
-	tests := []struct {
-		attempt int
-		want    time.Duration
-	}{
-		{0, 1 * time.Second},
-		{1, 2 * time.Second},
-		{2, 4 * time.Second},
-	}
-
-	for _, tt := range tests {
-		delay := c.retryDelay(resp, tt.attempt)
-		if delay != tt.want {
-			t.Errorf("attempt %d: got %v, want %v", tt.attempt, delay, tt.want)
-		}
-	}
-}

internal/handlers/handlers.go

@@ -181,11 +181,58 @@ func renderPage(w http.ResponseWriter, r *http.Request, title, activeTab string,
 	}
 }
 
+// errorData holds the template data for error pages.
+type errorData struct {
+	Code    int
+	Title   string
+	Message string
+}
+
+// ErrorNotFound renders a mobile-friendly 404 error page.
+func (h *Handler) ErrorNotFound(w http.ResponseWriter, r *http.Request) {
+	data := errorData{
+		Code:    http.StatusNotFound,
+		Title:   "Page Not Found",
+		Message: "The page you are looking for does not exist or has been moved.",
+	}
+	h.renderError(w, r, data)
+}
+
+// ErrorInternal renders a mobile-friendly 500 error page.
+func (h *Handler) ErrorInternal(w http.ResponseWriter, r *http.Request) {
+	data := errorData{
+		Code:    http.StatusInternalServerError,
+		Title:   "Internal Server Error",
+		Message: "Something went wrong on our end. Please try again later.",
+	}
+	h.renderError(w, r, data)
+}
+
+// renderError renders the error template with the given data and status code.
+func (h *Handler) renderError(w http.ResponseWriter, r *http.Request, data errorData) {
+	tmpl, err := template.ParseFiles("internal/templates/error.html")
+	if err != nil {
+		slog.Error("failed to parse error template", "error", err)
+		http.Error(w, fmt.Sprintf("%d %s", data.Code, data.Title), data.Code)
+		return
+	}
+
+	var buf strings.Builder
+	if err := tmpl.ExecuteTemplate(&buf, "content", data); err != nil {
+		slog.Error("failed to execute error template", "error", err)
+		http.Error(w, fmt.Sprintf("%d %s", data.Code, data.Title), data.Code)
+		return
+	}
+
+	w.WriteHeader(data.Code)
+	renderPage(w, r, data.Title, "", buf.String())
+}
+
 // Dashboard handles GET / — the triage queue.
 func (h *Handler) Dashboard(w http.ResponseWriter, r *http.Request) {
 	// Only handle exact root path.
 	if r.URL.Path != "/" {
-		http.NotFound(w, r)
+		h.ErrorNotFound(w, r)
 		return
 	}
 

internal/handlers/handlers_test.go

@@ -183,6 +183,87 @@ func TestAddComment_EmptyBody(t *testing.T) {
 	}
 }
 
+func TestErrorNotFound(t *testing.T) {
+	h := newTestHandler()
+	req := httptest.NewRequest(http.MethodGet, "/nonexistent", nil)
+	w := httptest.NewRecorder()
+
+	h.ErrorNotFound(w, req)
+
+	if w.Code != http.StatusNotFound {
+		t.Errorf("status = %d, want %d", w.Code, http.StatusNotFound)
+	}
+	body := w.Body.String()
+	if body == "" {
+		t.Error("expected non-empty response body")
+	}
+	if !contains(body, "404") {
+		t.Error("expected body to contain '404'")
+	}
+	if !contains(body, "Page Not Found") {
+		t.Error("expected body to contain 'Page Not Found'")
+	}
+}
+
+func TestErrorInternal(t *testing.T) {
+	h := newTestHandler()
+	req := httptest.NewRequest(http.MethodGet, "/error", nil)
+	w := httptest.NewRecorder()
+
+	h.ErrorInternal(w, req)
+
+	if w.Code != http.StatusInternalServerError {
+		t.Errorf("status = %d, want %d", w.Code, http.StatusInternalServerError)
+	}
+	body := w.Body.String()
+	if body == "" {
+		t.Error("expected non-empty response body")
+	}
+	if !contains(body, "500") {
+		t.Error("expected body to contain '500'")
+	}
+	if !contains(body, "Internal Server Error") {
+		t.Error("expected body to contain 'Internal Server Error'")
+	}
+}
+
+func TestDashboard_NonRootPath_Returns404(t *testing.T) {
+	h := newTestHandler()
+	req := httptest.NewRequest(http.MethodGet, "/unknown/path", nil)
+	w := httptest.NewRecorder()
+
+	h.Dashboard(w, req)
+
+	if w.Code != http.StatusNotFound {
+		t.Errorf("status = %d, want %d", w.Code, http.StatusNotFound)
+	}
+	body := w.Body.String()
+	if !contains(body, "404") {
+		t.Error("expected body to contain '404' for non-root path")
+	}
+}
+
+func TestErrorNotFound_HTMX(t *testing.T) {
+	h := newTestHandler()
+	req := httptest.NewRequest(http.MethodGet, "/nonexistent", nil)
+	req.Header.Set("HX-Request", "true")
+	w := httptest.NewRecorder()
+
+	h.ErrorNotFound(w, req)
+
+	if w.Code != http.StatusNotFound {
+		t.Errorf("status = %d, want %d", w.Code, http.StatusNotFound)
+	}
+	body := w.Body.String()
+	// HTMX response should not contain DOCTYPE.
+	if contains(body, "<!DOCTYPE") {
+		t.Error("HTMX response should not contain DOCTYPE")
+	}
+	if !contains(body, "Page Not Found") {
+		t.Error("expected body to contain 'Page Not Found'")
+	}
+}
+
 func contains(s, substr string) bool {
 	return len(s) >= len(substr) && searchString(s, substr)
 }

internal/templates/error.html

@@ -0,0 +1,23 @@
+{{define "content"}}
+<div class="error-page">
+  <div class="error-icon">
+    {{if eq .Code 404}}
+    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" width="64" height="64">
+      <circle cx="11" cy="11" r="8"/>
+      <line x1="21" y1="21" x2="16.65" y2="16.65"/>
+      <line x1="8" y1="11" x2="14" y2="11"/>
+    </svg>
+    {{else}}
+    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" width="64" height="64">
+      <path d="M10.29 3.86L1.82 18a2 2 0 001.71 3h16.94a2 2 0 001.71-3L13.71 3.86a2 2 0 00-3.42 0z"/>
+      <line x1="12" y1="9" x2="12" y2="13"/>
+      <line x1="12" y1="17" x2="12.01" y2="17"/>
+    </svg>
+    {{end}}
+  </div>
+  <h1 class="error-code">{{.Code}}</h1>
+  <p class="error-title">{{.Title}}</p>
+  <p class="error-message">{{.Message}}</p>
+  <a href="/" class="error-home-link">Go to Dashboard</a>
+</div>
+{{end}}

static/style.css

@@ -545,3 +545,56 @@ a:active {
     --text-link: #0969da;
   }
 }
+
+/* Error page */
+.error-page {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  min-height: 60vh;
+  text-align: center;
+  padding: var(--spacing-lg);
+}
+
+.error-icon {
+  color: var(--text-secondary);
+  margin-bottom: var(--spacing-lg);
+}
+
+.error-code {
+  font-size: 4rem;
+  font-weight: 700;
+  color: var(--text-primary);
+  line-height: 1;
+  margin-bottom: var(--spacing-sm);
+}
+
+.error-title {
+  font-size: var(--font-xl);
+  color: var(--text-primary);
+  margin-bottom: var(--spacing-sm);
+}
+
+.error-message {
+  font-size: var(--font-base);
+  color: var(--text-secondary);
+  margin-bottom: var(--spacing-lg);
+  max-width: 300px;
+}
+
+.error-home-link {
+  display: inline-block;
+  padding: var(--spacing-sm) var(--spacing-lg);
+  background: var(--accent-blue);
+  color: #fff;
+  border-radius: var(--radius);
+  text-decoration: none;
+  font-size: var(--font-base);
+  font-weight: 500;
+  transition: opacity 0.15s;
+}
+
+.error-home-link:active {
+  opacity: 0.8;
+}