Skip to content

High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.

47.0 KB
Raw Blame
package handlers

import (
	"crypto/tls"
	"net/http"
	"net/http/httptest"
	"testing"
	"time"

	"github.com/pinchtab/pinchtab/internal/activity"
	"github.com/pinchtab/pinchtab/internal/authn"
	"github.com/pinchtab/pinchtab/internal/browsersession"
	"github.com/pinchtab/pinchtab/internal/config"
	"github.com/pinchtab/pinchtab/internal/httpx"
	"github.com/pinchtab/pinchtab/internal/session"
)

type activityCaptureRecorder struct {
	events []activity.Event
}

func (c *activityCaptureRecorder) Enabled() bool { return true }

func (c *activityCaptureRecorder) Record(evt activity.Event) error {
	c.events = append(c.events, evt)
	return nil
}

func (c *activityCaptureRecorder) Query(activity.Filter) ([]activity.Event, error) {
	return append([]activity.Event(nil), c.events...), nil
}

func resetRateLimitStateForTests() {
	rateMu.Lock()
	rateBuckets = map[string][]time.Time{}
	rateMu.Unlock()

	streamMu.Lock()
	streamConnections = map[string]int{}
	streamMu.Unlock()
}

func TestAuthMiddleware_NoToken(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: ""}

	called := false
	handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest("GET", "/test", nil)
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if called {
		t.Error("handler should NOT have been called when token is missing")
	}
	if w.Code != http.StatusServiceUnavailable {
		t.Fatalf("expected 503 when token is missing, got %d", w.Code)
	}
}

func TestSecurityHeadersMiddleware_AddsHeaders(t *testing.T) {
	handler := SecurityHeadersMiddleware(nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodGet, "/dashboard", nil)
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if got := w.Header().Get("X-Content-Type-Options"); got != "nosniff" {
		t.Fatalf("X-Content-Type-Options = %q, want nosniff", got)
	}
	if got := w.Header().Get("X-Frame-Options"); got != "DENY" {
		t.Fatalf("X-Frame-Options = %q, want DENY", got)
	}
	if got := w.Header().Get("Content-Security-Policy"); got != defaultCSP {
		t.Fatalf("Content-Security-Policy = %q, want %q", got, defaultCSP)
	}
	if got := w.Header().Get("Strict-Transport-Security"); got != "" {
		t.Fatalf("Strict-Transport-Security = %q, want empty for http requests", got)
	}
}

func TestSecurityHeadersMiddleware_AddsHSTSForTLS(t *testing.T) {
	handler := SecurityHeadersMiddleware(nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	}))

	request := httptest.NewRequest(http.MethodGet, "https://pinchtab.test/dashboard", nil)
	request.TLS = &tls.ConnectionState{}
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, request)

	if got := w.Header().Get("Strict-Transport-Security"); got != strictTransportSecurity {
		t.Fatalf("Strict-Transport-Security = %q, want %q", got, strictTransportSecurity)
	}
}

func TestSecurityHeadersMiddleware_UsesTrustedForwardedProtoForHSTS(t *testing.T) {
	handler := SecurityHeadersMiddleware(config.NewLive(&config.RuntimeConfig{TrustProxyHeaders: true}), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	}))

	request := httptest.NewRequest(http.MethodGet, "http://pinchtab/dashboard", nil)
	request.Header.Set("X-Forwarded-Proto", "https")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, request)

	if got := w.Header().Get("Strict-Transport-Security"); got != strictTransportSecurity {
		t.Fatalf("Strict-Transport-Security = %q, want %q", got, strictTransportSecurity)
	}
}

func TestAuthMiddleware_ValidToken(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}

	called := false
	handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest("GET", "/test", nil)
	req.Header.Set("Authorization", "Bearer secret123")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if !called {
		t.Error("handler should have been called with valid token")
	}
}

func TestAuthMiddleware_AllowsBackgroundHealthProbeMarker(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123", BackgroundMarker: "marker-123"}

	called := false
	handler := StripInternalHeadersMiddleware(AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(http.StatusOK)
	})))

	req := httptest.NewRequest(http.MethodGet, backgroundHealthPath, nil)
	req.Header.Set(backgroundHealthHeader, "marker-123")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf("status = %d, want 200", w.Code)
	}
	if !called {
		t.Fatal("handler should have been called with the background marker")
	}
}

func TestAuthMiddleware_RejectsWrongBackgroundHealthProbeMarker(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123", BackgroundMarker: "marker-123"}

	called := false
	handler := StripInternalHeadersMiddleware(AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(http.StatusOK)
	})))

	req := httptest.NewRequest(http.MethodGet, backgroundHealthPath, nil)
	req.Header.Set(backgroundHealthHeader, "other")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if w.Code != http.StatusUnauthorized {
		t.Fatalf("status = %d, want 401", w.Code)
	}
	if called {
		t.Fatal("handler should not have been called with the wrong background marker")
	}
}

func TestAuthMiddleware_InvalidToken(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}

	called := false
	handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
	}))

	req := httptest.NewRequest("GET", "/test", nil)
	req.Header.Set("Authorization", "Bearer wrong")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if called {
		t.Error("handler should NOT have been called with invalid token")
	}
	if w.Code != 401 {
		t.Errorf("expected 401, got %d", w.Code)
	}
	if w.Header().Get("WWW-Authenticate") == "" {
		t.Error("expected WWW-Authenticate header")
	}
}

func TestAuthMiddleware_MissingTokenHeader(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}

	handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest("GET", "/test", nil)
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if w.Code != 401 {
		t.Errorf("expected 401, got %d", w.Code)
	}
	if w.Header().Get("WWW-Authenticate") == "" {
		t.Error("expected WWW-Authenticate header")
	}
}

func TestAuthMiddleware_ValidCookie(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}
	sessions := browsersession.NewManager(browsersession.Config{})
	sessionID, err := sessions.Create(cfg.Token)
	if err != nil {
		t.Fatalf("Create() error = %v", err)
	}

	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest("GET", "/health", nil)
	req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
	req.Header.Set("Referer", "http://example.com/dashboard")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if !called {
		t.Fatal("handler should have been called with valid cookie auth")
	}
	if w.Code != 200 {
		t.Fatalf("expected 200, got %d", w.Code)
	}
}

func TestAuthMiddleware_CookieRestrictedEndpointRejected(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}
	sessions := browsersession.NewManager(browsersession.Config{})
	sessionID, err := sessions.Create(cfg.Token)
	if err != nil {
		t.Fatalf("Create() error = %v", err)
	}
	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest(http.MethodPost, "/evaluate", nil)
	req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if called {
		t.Fatal("handler should not allow cookie auth on restricted endpoint")
	}
	if w.Code != http.StatusForbidden {
		t.Fatalf("expected 403, got %d", w.Code)
	}
}

func TestAuthMiddleware_CookieAllowsTabCloseEndpoint(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}
	sessions := browsersession.NewManager(browsersession.Config{})
	sessionID, err := sessions.Create(cfg.Token)
	if err != nil {
		t.Fatalf("Create() error = %v", err)
	}

	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodPost, "/tabs/tab_123/close", nil)
	req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
	req.Header.Set("Referer", "http://example.com/dashboard")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if !called {
		t.Fatal("handler should allow same-origin cookie-authenticated tab close")
	}
	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", w.Code)
	}
}

func TestAuthMiddleware_CookieAllowsActionEndpoint(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}
	sessions := browsersession.NewManager(browsersession.Config{})
	sessionID, err := sessions.Create(cfg.Token)
	if err != nil {
		t.Fatalf("Create() error = %v", err)
	}

	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodPost, "/action", nil)
	req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
	req.Header.Set("Origin", "http://example.com")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if !called {
		t.Fatal("handler should allow same-origin cookie-authenticated actions from the dashboard")
	}
	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", w.Code)
	}
}

func TestAuthMiddleware_CookieAllowsInstanceStartEndpoint(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}
	sessions := browsersession.NewManager(browsersession.Config{})
	sessionID, err := sessions.Create(cfg.Token)
	if err != nil {
		t.Fatalf("Create() error = %v", err)
	}

	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodPost, "/instances/start", nil)
	req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
	req.Header.Set("Origin", "http://example.com")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if !called {
		t.Fatal("handler should allow same-origin cookie-authenticated instance start from the dashboard")
	}
	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", w.Code)
	}
}

func TestAuthMiddleware_CookieCrossOriginRejected(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}
	sessions := browsersession.NewManager(browsersession.Config{})
	sessionID, err := sessions.Create(cfg.Token)
	if err != nil {
		t.Fatalf("Create() error = %v", err)
	}

	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodGet, "/health", nil)
	req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
	req.Header.Set("Origin", "https://evil.example")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if called {
		t.Fatal("handler should not allow cross-origin cookie auth")
	}
	if w.Code != http.StatusForbidden {
		t.Fatalf("expected 403, got %d", w.Code)
	}
}

func TestAuthMiddleware_CookieRequestWithoutOriginOrRefererRejected(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}
	sessions := browsersession.NewManager(browsersession.Config{})
	sessionID, err := sessions.Create(cfg.Token)
	if err != nil {
		t.Fatalf("Create() error = %v", err)
	}

	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodGet, "/health", nil)
	req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if called {
		t.Fatal("handler should not allow cookie auth without same-origin headers")
	}
	if w.Code != http.StatusForbidden {
		t.Fatalf("expected 403, got %d", w.Code)
	}
}

func TestAuthMiddleware_CookieSameOriginRefererAccepted(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}
	sessions := browsersession.NewManager(browsersession.Config{})
	sessionID, err := sessions.Create(cfg.Token)
	if err != nil {
		t.Fatalf("Create() error = %v", err)
	}

	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodGet, "/health", nil)
	req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
	req.Header.Set("Referer", "http://example.com/dashboard")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if !called {
		t.Fatal("handler should allow same-origin cookie-authenticated request with referer")
	}
	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", w.Code)
	}
}

func TestAuthMiddleware_CookieIgnoresForwardedOriginHints(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}
	sessions := browsersession.NewManager(browsersession.Config{})
	sessionID, err := sessions.Create(cfg.Token)
	if err != nil {
		t.Fatalf("Create() error = %v", err)
	}

	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodGet, "/health", nil)
	req.Host = "127.0.0.1:9867"
	req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
	req.Header.Set("Origin", "https://pinchtab.example")
	req.Header.Set("X-Forwarded-Proto", "https")
	req.Header.Set("X-Forwarded-Host", "pinchtab.example")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if called {
		t.Fatal("handler should ignore forwarded host/proto headers for cookie same-origin checks")
	}
	if w.Code != http.StatusForbidden {
		t.Fatalf("expected 403, got %d", w.Code)
	}
}

func TestAuthMiddleware_CookieWebSocketRequiresSameOrigin(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}
	sessions := browsersession.NewManager(browsersession.Config{})
	sessionID, err := sessions.Create(cfg.Token)
	if err != nil {
		t.Fatalf("Create() error = %v", err)
	}

	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodGet, "/instances/inst1/proxy/screencast", nil)
	req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
	req.Header.Set("Connection", "Upgrade")
	req.Header.Set("Upgrade", "websocket")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if called {
		t.Fatal("handler should not allow cookie-authenticated websocket upgrade without an Origin header")
	}
	if w.Code != http.StatusForbidden {
		t.Fatalf("expected 403, got %d", w.Code)
	}

	called = false
	req = httptest.NewRequest(http.MethodGet, "/instances/inst1/proxy/screencast", nil)
	req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
	req.Header.Set("Connection", "Upgrade")
	req.Header.Set("Upgrade", "websocket")
	req.Header.Set("Origin", "http://example.com")
	w = httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if !called {
		t.Fatal("handler should allow same-origin cookie-authenticated websocket upgrade")
	}
	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", w.Code)
	}
}

func TestAuthMiddleware_CookieElevatedEndpointRequiresElevation(t *testing.T) {
	cfg := &config.RuntimeConfig{
		Token: "secret123",
		Sessions: config.SessionsRuntimeConfig{
			Dashboard: config.DashboardSessionRuntimeConfig{
				RequireElevation: true,
			},
		},
	}
	sessions := browsersession.NewManager(browsersession.Config{})
	sessionID, err := sessions.Create(cfg.Token)
	if err != nil {
		t.Fatalf("Create() error = %v", err)
	}

	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodPut, "/api/config", nil)
	req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
	req.Header.Set("Referer", "http://example.com/dashboard")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if called {
		t.Fatal("handler should not allow elevated endpoint without elevation")
	}
	if w.Code != http.StatusForbidden {
		t.Fatalf("expected 403, got %d", w.Code)
	}

	if !sessions.Elevate(sessionID, cfg.Token) {
		t.Fatal("expected session elevation to succeed in test setup")
	}

	called = false
	req = httptest.NewRequest(http.MethodPut, "/api/config", nil)
	req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
	req.Header.Set("Referer", "http://example.com/dashboard")
	w = httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if !called {
		t.Fatal("handler should allow elevated endpoint with elevation")
	}
	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", w.Code)
	}
}

func TestAuthMiddleware_CookieConfigEndpointDoesNotRequireElevationByDefault(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}
	sessions := browsersession.NewManager(browsersession.Config{})
	sessionID, err := sessions.Create(cfg.Token)
	if err != nil {
		t.Fatalf("Create() error = %v", err)
	}

	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodPut, "/api/config", nil)
	req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
	req.Header.Set("Referer", "http://example.com/dashboard")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if !called {
		t.Fatal("handler should allow config endpoint without elevation when requireElevation is disabled")
	}
	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", w.Code)
	}
}

func TestAuthMiddleware_HeaderAllowsRestrictedEndpoint(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}
	called := false
	handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest(http.MethodPost, "/evaluate", nil)
	req.Header.Set("Authorization", "Bearer secret123")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if !called {
		t.Fatal("handler should allow header auth on restricted endpoint")
	}
	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", w.Code)
	}
}

func TestAuthMiddleware_QueryTokenRejected(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}

	called := false
	handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest("GET", "/test?token=secret123", nil)
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if called {
		t.Fatal("handler should not accept query-string tokens")
	}
	if w.Code != 401 {
		t.Fatalf("expected 401, got %d", w.Code)
	}
}

func TestAuthMiddleware_PublicDashboardPathBypassesAuth(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}
	called := false
	handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest("GET", "/login", nil)
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if !called {
		t.Fatal("handler should have been called for public dashboard path")
	}
	if w.Code != 200 {
		t.Fatalf("expected 200, got %d", w.Code)
	}
}

func TestAuthMiddleware_PublicDashboardSubpathBypassesAuth(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}
	called := false
	handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest("GET", "/dashboard/monitoring", nil)
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if !called {
		t.Fatal("handler should have been called for public dashboard subpath")
	}
	if w.Code != 200 {
		t.Fatalf("expected 200, got %d", w.Code)
	}
}

func TestAuthMiddleware_PublicAuthPathBypassesAuth(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}
	called := false
	handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest("POST", "/api/auth/login", nil)
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if !called {
		t.Fatal("handler should have been called for public auth path")
	}
	if w.Code != 200 {
		t.Fatalf("expected 200, got %d", w.Code)
	}
}

func TestAuthMiddleware_ProtectedAPIStillRequiresAuth(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "secret123"}
	handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest("GET", "/api/config", nil)
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if w.Code != 401 {
		t.Fatalf("expected 401, got %d", w.Code)
	}
}

func TestAuthMiddleware_TableDriven(t *testing.T) {
	tests := []struct {
		name       string
		token      string
		authHeader string
		wantCode   int
		wantCalled bool
	}{
		{"correct token", "secret", "Bearer secret", 200, true},
		{"wrong token", "secret", "Bearer wrong", 401, false},
		{"partial match", "secret", "Bearer secre", 401, false},
		{"empty bearer", "secret", "Bearer ", 401, false},
		{"missing header", "secret", "", 401, false},
		{"query token rejected", "secret", "", 401, false},
		{"no token configured", "", "", http.StatusServiceUnavailable, false},
		{"no token configured with header", "", "Bearer anything", http.StatusServiceUnavailable, false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cfg := &config.RuntimeConfig{Token: tt.token}
			called := false
			handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				called = true
				w.WriteHeader(200)
			}))

			req := httptest.NewRequest("GET", "/test", nil)
			if tt.name == "query token rejected" {
				req = httptest.NewRequest("GET", "/test?token=secret", nil)
			}
			if tt.authHeader != "" {
				req.Header.Set("Authorization", tt.authHeader)
			}
			w := httptest.NewRecorder()
			handler.ServeHTTP(w, req)

			if called != tt.wantCalled {
				t.Errorf("handler called = %v, want %v", called, tt.wantCalled)
			}
			if w.Code != tt.wantCode {
				t.Errorf("status = %d, want %d", w.Code, tt.wantCode)
			}
		})
	}
}

func TestCorsMiddleware(t *testing.T) {
	handler := CorsMiddleware(config.NewLive(&config.RuntimeConfig{}), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest("OPTIONS", "/test", nil)
	req.Header.Set("Origin", "https://evil.example")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)
	if w.Code != 204 {
		t.Errorf("OPTIONS expected 204, got %d", w.Code)
	}
	if w.Header().Get("Access-Control-Allow-Origin") != "*" {
		t.Error("missing CORS origin header")
	}

	req = httptest.NewRequest("GET", "/test", nil)
	req.Header.Set("Origin", "https://evil.example")
	w = httptest.NewRecorder()
	handler.ServeHTTP(w, req)
	if w.Code != 200 {
		t.Errorf("GET expected 200, got %d", w.Code)
	}
	if w.Header().Get("Access-Control-Allow-Origin") != "*" {
		t.Error("missing CORS origin header on GET")
	}
}

func TestCorsMiddleware_AuthEnabledAllowsOnlySameOrigin(t *testing.T) {
	handler := CorsMiddleware(config.NewLive(&config.RuntimeConfig{Token: "secret"}), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest("OPTIONS", "/test", nil)
	req.Host = "pinchtab.test"
	req.Header.Set("Origin", "http://pinchtab.test")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if w.Code != 204 {
		t.Fatalf("OPTIONS expected 204, got %d", w.Code)
	}
	if got := w.Header().Get("Access-Control-Allow-Origin"); got != "http://pinchtab.test" {
		t.Fatalf("Access-Control-Allow-Origin = %q, want same origin", got)
	}
	if got := w.Header().Get("Access-Control-Allow-Credentials"); got != "true" {
		t.Fatalf("Access-Control-Allow-Credentials = %q, want true", got)
	}
}

func TestCorsMiddleware_AuthEnabledRejectsCrossOriginPreflight(t *testing.T) {
	handler := CorsMiddleware(config.NewLive(&config.RuntimeConfig{Token: "secret"}), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest("OPTIONS", "/test", nil)
	req.Host = "pinchtab.test"
	req.Header.Set("Origin", "https://evil.example")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if w.Code != http.StatusForbidden {
		t.Fatalf("OPTIONS expected 403, got %d", w.Code)
	}
	if got := w.Header().Get("Access-Control-Allow-Origin"); got != "" {
		t.Fatalf("Access-Control-Allow-Origin = %q, want empty", got)
	}
}

func TestLoggingMiddleware(t *testing.T) {
	resetObservabilityForTests()
	handler := LoggingMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(201)
	}))

	req := httptest.NewRequest("GET", "/test", nil)
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if w.Code != 201 {
		t.Errorf("expected 201, got %d", w.Code)
	}
}

func TestLoggingMiddleware_RecordsFailure(t *testing.T) {
	resetObservabilityForTests()
	handler := RequestIDMiddleware(LoggingMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusInternalServerError)
	})))

	req := httptest.NewRequest("GET", "/boom", nil)
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	snap := FailureSnapshot(LayerInstance)
	if got := snap["requestsFailed"].(uint64); got != 1 {
		t.Fatalf("requestsFailed = %d, want 1", got)
	}
	recent, ok := snap["recent"].([]map[string]any)
	if !ok || len(recent) != 1 {
		t.Fatalf("recent failures = %#v, want 1 event", snap["recent"])
	}
	if recent[0]["path"] != "/boom" {
		t.Fatalf("recent path = %v, want /boom", recent[0]["path"])
	}
	if recent[0]["requestId"] == "" {
		t.Fatal("expected request id on failure event")
	}
}

func TestStripInternalHeadersMiddleware_RemovesPinchtabHeaders(t *testing.T) {
	var seen http.Header
	handler := StripInternalHeadersMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		seen = r.Header.Clone()
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest("GET", "/test", nil)
	req.Header.Set("X-PinchTab-Session-Id", "spoofed")
	req.Header.Set("X-PinchTab-Tab-Id", "tab-spoof")
	req.Header.Set("x-pinchtab-source", "evil")
	req.Header.Set("Authorization", "Session abc")
	req.Header.Set("X-Other", "keep-me")

	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	for _, h := range []string{"X-PinchTab-Session-Id", "X-PinchTab-Tab-Id", "X-Pinchtab-Source"} {
		if seen.Get(h) != "" {
			t.Fatalf("expected %s to be stripped, got %q", h, seen.Get(h))
		}
	}
	if seen.Get("Authorization") != "Session abc" {
		t.Fatal("Authorization should be preserved")
	}
	if seen.Get("X-Other") != "keep-me" {
		t.Fatal("non-pinchtab headers should be preserved")
	}
}

func TestTrustedInternalProxyStripMiddleware_ValidTokenMarksContextAndPreservesHeaders(t *testing.T) {
	const secret = "shared-internal-secret"
	var (
		seenSession string
		seenTrusted bool
		seenToken   string
	)
	mw := TrustedInternalProxyStripMiddleware(secret)
	handler := mw(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		seenSession = r.Header.Get("X-PinchTab-Session-Id")
		seenTrusted = IsTrustedInternalProxy(r)
		seenToken = r.Header.Get(InternalTokenHeader)
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest("GET", "/x", nil)
	req.Header.Set(InternalTokenHeader, secret)
	req.Header.Set("X-PinchTab-Session-Id", "ses_propagated")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if !seenTrusted {
		t.Fatal("expected request to be marked trusted-internal-proxy")
	}
	if seenSession != "ses_propagated" {
		t.Fatalf("session header = %q, want ses_propagated", seenSession)
	}
	if seenToken != "" {
		t.Fatalf("internal token header should be removed, got %q", seenToken)
	}
}

func TestTrustedInternalProxyStripMiddleware_BadTokenStripsHeaders(t *testing.T) {
	var (
		seenSession string
		seenTrusted bool
	)
	mw := TrustedInternalProxyStripMiddleware("expected-secret")
	handler := mw(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		seenSession = r.Header.Get("X-PinchTab-Session-Id")
		seenTrusted = IsTrustedInternalProxy(r)
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest("GET", "/x", nil)
	req.Header.Set(InternalTokenHeader, "wrong-secret")
	req.Header.Set("X-PinchTab-Session-Id", "spoofed")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if seenTrusted {
		t.Fatal("expected untrusted request not to be marked")
	}
	if seenSession != "" {
		t.Fatalf("session header should be stripped, got %q", seenSession)
	}
}

func TestTrustedInternalProxyStripMiddleware_EmptySecretAlwaysStrips(t *testing.T) {
	var (
		seenSession string
		seenTrusted bool
	)
	mw := TrustedInternalProxyStripMiddleware("")
	handler := mw(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		seenSession = r.Header.Get("X-PinchTab-Session-Id")
		seenTrusted = IsTrustedInternalProxy(r)
		w.WriteHeader(200)
	}))

	// Even when the request looks like it has the right header, an empty
	// configured secret means trust verification is disabled — always strip.
	req := httptest.NewRequest("GET", "/x", nil)
	req.Header.Set(InternalTokenHeader, "anything")
	req.Header.Set("X-PinchTab-Session-Id", "spoofed")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if seenTrusted {
		t.Fatal("empty secret must never mark trusted")
	}
	if seenSession != "" {
		t.Fatal("empty secret must still strip pinchtab headers")
	}
}

func TestRequestIDMiddleware_SetsHeader(t *testing.T) {
	handler := RequestIDMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(200)
	}))
	req := httptest.NewRequest("GET", "/test", nil)
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)
	if w.Header().Get("X-Request-Id") == "" {
		t.Fatal("expected X-Request-Id")
	}
}

func TestRateLimitMiddleware_AllowsRequest(t *testing.T) {
	resetRateLimitStateForTests()
	t.Cleanup(resetRateLimitStateForTests)

	handler := RateLimitMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(200)
	}))
	req := httptest.NewRequest("GET", "/test", nil)
	req.RemoteAddr = "127.0.0.1:12345"
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)
	if w.Code != 200 {
		t.Fatalf("expected 200, got %d", w.Code)
	}
}

func TestRateLimitMiddleware_RateLimitsHealthAndMetrics(t *testing.T) {
	resetRateLimitStateForTests()
	t.Cleanup(resetRateLimitStateForTests)

	handler := RateLimitMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(200)
	}))
	for _, p := range []string{"/health", "/metrics"} {
		resetRateLimitStateForTests()
		for i := 0; i < rateLimitMaxReq; i++ {
			req := httptest.NewRequest("GET", p, nil)
			req.RemoteAddr = "127.0.0.1:12345"
			w := httptest.NewRecorder()
			handler.ServeHTTP(w, req)
			if w.Code != http.StatusOK {
				t.Fatalf("%s request %d: expected 200, got %d", p, i+1, w.Code)
			}
		}

		req := httptest.NewRequest("GET", p, nil)
		req.RemoteAddr = "127.0.0.1:12345"
		w := httptest.NewRecorder()
		handler.ServeHTTP(w, req)
		if w.Code != http.StatusTooManyRequests {
			t.Fatalf("expected 429 for %s after limit exceeded, got %d", p, w.Code)
		}
	}
}

func TestRateLimitMiddleware_DoesNotRateLimitStreamingEndpoints(t *testing.T) {
	resetRateLimitStateForTests()
	t.Cleanup(resetRateLimitStateForTests)

	handler := RateLimitMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	}))

	for _, p := range []string{
		"/api/events",
		"/api/agents/agent-1/events",
		"/instances/inst-1/logs/stream",
	} {
		resetRateLimitStateForTests()
		for i := 0; i < rateLimitMaxReq+5; i++ {
			req := httptest.NewRequest(http.MethodGet, p, nil)
			req.RemoteAddr = "127.0.0.1:12345"
			w := httptest.NewRecorder()
			handler.ServeHTTP(w, req)
			if w.Code != http.StatusOK {
				t.Fatalf("%s request %d: expected 200, got %d", p, i+1, w.Code)
			}
		}
	}
}

func TestRateLimitMiddleware_LimitsConcurrentStreamingEndpointsPerHost(t *testing.T) {
	resetRateLimitStateForTests()
	t.Cleanup(resetRateLimitStateForTests)

	entered := make(chan struct{}, maxConcurrentStreamRequestsPerHost)
	release := make(chan struct{})
	results := make(chan int, maxConcurrentStreamRequestsPerHost)

	handler := RateLimitMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		entered <- struct{}{}
		<-release
		w.WriteHeader(http.StatusOK)
	}))

	for i := 0; i < maxConcurrentStreamRequestsPerHost; i++ {
		go func() {
			req := httptest.NewRequest(http.MethodGet, "/api/events", nil)
			req.RemoteAddr = "127.0.0.1:12345"
			w := httptest.NewRecorder()
			handler.ServeHTTP(w, req)
			results <- w.Code
		}()
	}

	for i := 0; i < maxConcurrentStreamRequestsPerHost; i++ {
		select {
		case <-entered:
		case <-time.After(2 * time.Second):
			t.Fatalf("timed out waiting for stream %d to enter handler", i+1)
		}
	}

	req := httptest.NewRequest(http.MethodGet, "/api/events", nil)
	req.RemoteAddr = "127.0.0.1:12345"
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)
	if w.Code != http.StatusTooManyRequests {
		t.Fatalf("expected 429 once concurrent stream limit is reached, got %d", w.Code)
	}

	close(release)

	for i := 0; i < maxConcurrentStreamRequestsPerHost; i++ {
		select {
		case code := <-results:
			if code != http.StatusOK {
				t.Fatalf("stream %d completed with %d, want 200", i+1, code)
			}
		case <-time.After(2 * time.Second):
			t.Fatalf("timed out waiting for stream %d to complete", i+1)
		}
	}
}

func TestRateLimitMiddleware_IgnoresSpoofedForwardedHeaders(t *testing.T) {
	resetRateLimitStateForTests()
	t.Cleanup(resetRateLimitStateForTests)

	now := time.Now()
	hits := make([]time.Time, rateLimitMaxReq)
	for i := range hits {
		hits[i] = now
	}

	rateMu.Lock()
	rateBuckets["198.51.100.10"] = hits
	rateMu.Unlock()

	handler := RateLimitMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodGet, "/test", nil)
	req.RemoteAddr = "198.51.100.10:41000"
	req.Header.Set("X-Forwarded-For", "203.0.113.1")
	req.Header.Set("X-Real-Ip", "203.0.113.2")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)

	if w.Code != http.StatusTooManyRequests {
		t.Fatalf("expected 429 when forwarded headers spoof a new IP, got %d", w.Code)
	}
}

func TestEvictStaleRateBuckets_DeletesEmptyHosts(t *testing.T) {
	resetRateLimitStateForTests()
	t.Cleanup(resetRateLimitStateForTests)

	now := time.Now()
	window := 10 * time.Second

	rateMu.Lock()
	rateBuckets = map[string][]time.Time{
		"stale-only": {now.Add(-2 * window)},
		"mixed":      {now.Add(-2 * window), now.Add(-window / 2)},
		"fresh":      {now.Add(-window / 3)},
	}
	rateMu.Unlock()

	evictStaleRateBuckets(now, window)

	rateMu.Lock()
	defer rateMu.Unlock()

	if _, ok := rateBuckets["stale-only"]; ok {
		t.Fatal("expected stale-only bucket to be deleted")
	}
	if got := len(rateBuckets["mixed"]); got != 1 {
		t.Fatalf("expected mixed bucket to keep 1 hit, got %d", got)
	}
	if got := len(rateBuckets["fresh"]); got != 1 {
		t.Fatalf("expected fresh bucket to keep 1 hit, got %d", got)
	}
}

func TestStatusWriter(t *testing.T) {
	w := httptest.NewRecorder()
	sw := &httpx.StatusWriter{ResponseWriter: w, Code: 200}

	sw.WriteHeader(404)
	if sw.Code != 404 {
		t.Errorf("expected 404, got %d", sw.Code)
	}
}

func TestAuthMiddleware_SessionAuth(t *testing.T) {
	store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})
	_, token, _ := store.Create("test-agent", "test", "")

	cfg := &config.RuntimeConfig{Token: "server-token"}
	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(200)
	}))

	req := httptest.NewRequest("GET", "/health", nil)
	req.Header.Set("Authorization", "Session "+token)
	rr := httptest.NewRecorder()
	handler.ServeHTTP(rr, req)

	if !called {
		t.Fatal("expected handler to be called with valid session token")
	}
	if rr.Code != 200 {
		t.Fatalf("expected 200, got %d", rr.Code)
	}
}

func TestAuthMiddleware_SessionAuthRejectsDashboardAdminRoute(t *testing.T) {
	store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})
	_, token, _ := store.Create("test-agent", "test", "")

	cfg := &config.RuntimeConfig{Token: "server-token"}
	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodGet, "/api/config", nil)
	req.Header.Set("Authorization", "Session "+token)
	rr := httptest.NewRecorder()
	handler.ServeHTTP(rr, req)

	if called {
		t.Fatal("handler should not be called for dashboard/admin route via session auth")
	}
	if rr.Code != http.StatusForbidden {
		t.Fatalf("expected 403, got %d", rr.Code)
	}
}

func TestAuthMiddleware_SessionAuthWithoutGrantsAllowsNonAdminRoutes(t *testing.T) {
	store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})
	_, token, _ := store.Create("test-agent", "test", "")

	cfg := &config.RuntimeConfig{Token: "server-token"}
	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodPost, "/evaluate", nil)
	req.Header.Set("Authorization", "Session "+token)
	rr := httptest.NewRecorder()
	handler.ServeHTTP(rr, req)

	if !called {
		t.Fatal("handler should be called for non-admin route when grants are empty")
	}
	if rr.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", rr.Code)
	}
}

func TestAuthMiddleware_SessionAuthAllowsRevokeRouteToReachHandler(t *testing.T) {
	store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})
	sessionID, token, _ := store.Create("test-agent", "test", "")

	cfg := &config.RuntimeConfig{Token: "server-token"}
	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodPost, "/sessions/"+sessionID+"/revoke", nil)
	req.Header.Set("Authorization", "Session "+token)
	rr := httptest.NewRecorder()
	handler.ServeHTTP(rr, req)

	if !called {
		t.Fatal("handler should be called for session revoke route")
	}
	if rr.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", rr.Code)
	}
}

func TestAuthMiddleware_SessionAuthHonorsBrowseGrant(t *testing.T) {
	store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})
	sessionID, token, _ := store.Create("test-agent", "test", "")
	if !store.SetGrants(sessionID, []string{"browse"}) {
		t.Fatal("expected session to exist")
	}

	cfg := &config.RuntimeConfig{Token: "server-token"}
	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodGet, "/text", nil)
	req.Header.Set("Authorization", "Session "+token)
	rr := httptest.NewRecorder()
	handler.ServeHTTP(rr, req)

	if !called {
		t.Fatal("handler should be called for route covered by browse grant")
	}
	if rr.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", rr.Code)
	}
}

func TestAuthMiddleware_SessionAuthRejectsRouteOutsideGrant(t *testing.T) {
	store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})
	sessionID, token, _ := store.Create("test-agent", "test", "")
	if !store.SetGrants(sessionID, []string{"browse"}) {
		t.Fatal("expected session to exist")
	}

	cfg := &config.RuntimeConfig{Token: "server-token"}
	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodGet, "/clipboard/read", nil)
	req.Header.Set("Authorization", "Session "+token)
	rr := httptest.NewRecorder()
	handler.ServeHTTP(rr, req)

	if called {
		t.Fatal("handler should not be called for route outside granted scope")
	}
	if rr.Code != http.StatusForbidden {
		t.Fatalf("expected 403, got %d", rr.Code)
	}
}

func TestAuthMiddleware_ForbiddenSessionRequestDoesNotExtendIdleLifetime(t *testing.T) {
	store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 100 * time.Millisecond, MaxLifetime: 24 * time.Hour})
	sessionID, token, _ := store.Create("test-agent", "test", "")
	if !store.SetGrants(sessionID, []string{"browse"}) {
		t.Fatal("expected session to exist")
	}

	cfg := &config.RuntimeConfig{Token: "server-token"}
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	}))

	time.Sleep(30 * time.Millisecond)

	req := httptest.NewRequest(http.MethodGet, "/clipboard/read", nil)
	req.Header.Set("Authorization", "Session "+token)
	rr := httptest.NewRecorder()
	handler.ServeHTTP(rr, req)

	if rr.Code != http.StatusForbidden {
		t.Fatalf("expected 403, got %d", rr.Code)
	}

	time.Sleep(90 * time.Millisecond)

	req = httptest.NewRequest(http.MethodGet, "/text", nil)
	req.Header.Set("Authorization", "Session "+token)
	rr = httptest.NewRecorder()
	handler.ServeHTTP(rr, req)

	if rr.Code != http.StatusUnauthorized {
		t.Fatalf("expected 401 after idle timeout, got %d", rr.Code)
	}
}

func TestAuthMiddleware_SessionAuthEnrichesActivity(t *testing.T) {
	store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})
	sessionID, token, _ := store.Create("test-agent", "test", "")
	rec := &activityCaptureRecorder{}

	cfg := &config.RuntimeConfig{Token: "server-token"}
	handler := activity.Middleware(rec, "server", AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	})))

	req := httptest.NewRequest(http.MethodGet, "/text", nil)
	req.Header.Set("Authorization", "Session "+token)
	rr := httptest.NewRecorder()
	handler.ServeHTTP(rr, req)

	if rr.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", rr.Code)
	}
	if len(rec.events) != 1 {
		t.Fatalf("len(events) = %d, want 1", len(rec.events))
	}
	if rec.events[0].SessionID != sessionID {
		t.Fatalf("event.SessionID = %q, want %q", rec.events[0].SessionID, sessionID)
	}
	if rec.events[0].AgentID != "test-agent" {
		t.Fatalf("event.AgentID = %q, want test-agent", rec.events[0].AgentID)
	}
}

func TestAuthMiddleware_SessionAttachesAuthenticatedSessionToContext(t *testing.T) {
	store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})
	_, token, _ := store.Create("test-agent", "test", "")

	var (
		called     bool
		gotSession *session.Session
	)
	cfg := &config.RuntimeConfig{Token: "server-token"}
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
		gotSession, _ = session.FromRequest(r)
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodGet, "/sessions/me", nil)
	req.Header.Set("Authorization", "Session "+token)
	rr := httptest.NewRecorder()
	handler.ServeHTTP(rr, req)

	if !called {
		t.Fatal("handler should have been called with valid session auth")
	}
	if rr.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", rr.Code)
	}
	if gotSession == nil {
		t.Fatal("expected agent session on request context")
	}
	if gotSession.AgentID != "test-agent" {
		t.Fatalf("AgentID = %q, want test-agent", gotSession.AgentID)
	}
}

func TestAuthMiddleware_HeaderAuthDoesNotAttachAgentSessionToContext(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "server-token"}

	var gotSession *session.Session
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		gotSession, _ = session.FromRequest(r)
		w.WriteHeader(http.StatusOK)
	}))

	req := httptest.NewRequest(http.MethodGet, "/health", nil)
	req.Header.Set("Authorization", "Bearer server-token")
	rr := httptest.NewRecorder()
	handler.ServeHTTP(rr, req)

	if rr.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", rr.Code)
	}
	if gotSession != nil {
		t.Fatal("expected no agent session on request context for bearer auth")
	}
}

func TestAuthMiddleware_SessionAuthInvalid(t *testing.T) {
	store := session.NewStore(session.Config{Enabled: true})

	cfg := &config.RuntimeConfig{Token: "server-token"}
	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
	}))

	req := httptest.NewRequest("GET", "/health", nil)
	req.Header.Set("Authorization", "Session ses_invalidtoken")
	rr := httptest.NewRecorder()
	handler.ServeHTTP(rr, req)

	if called {
		t.Fatal("handler should not be called with invalid session token")
	}
	if rr.Code != 401 {
		t.Fatalf("expected 401, got %d", rr.Code)
	}
}

func TestAuthMiddleware_SessionAuthDisabled(t *testing.T) {
	cfg := &config.RuntimeConfig{Token: "server-token"}
	called := false
	handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		called = true
	}))

	req := httptest.NewRequest("GET", "/health", nil)
	req.Header.Set("Authorization", "Session ses_sometoken")
	rr := httptest.NewRecorder()
	handler.ServeHTTP(rr, req)

	if called {
		t.Fatal("handler should not be called when agent sessions disabled")
	}
	if rr.Code != 401 {
		t.Fatalf("expected 401, got %d", rr.Code)
	}
}