feat(tui): add SLA reporting view

Full-screen SLA report accessible via [s] from detail panel.
Computes uptime%, downtime, outage count, longest outage, MTTR,
and MTBF from state_changes table. Includes daily breakdown with
bar chart, switchable time periods (24h/7d/30d/90d), and
scrollable viewport. LATE/STALE treated as UP for SLA purposes.

internal/alert/alert.go

@@ -110,6 +110,24 @@ func gotifyPayload(priority string) PayloadFunc {
 	}
 }
 
+func opsgeniePayload(priority string) PayloadFunc {
+	return func(title, message string) ([]byte, error) {
+		return json.Marshal(map[string]any{
+			"message":     limitMessage(title, 130),
+			"description": message,
+			"source":      "uptop",
+			"priority":    priority,
+		})
+	}
+}
+
+func limitMessage(s string, max int) string {
+	if len(s) <= max {
+		return s
+	}
+	return s[:max]
+}
+
 func GetProvider(cfg models.AlertConfig) Provider {
 	switch cfg.Type {
 	case "discord":
@@ -173,6 +191,20 @@ func GetProvider(cfg models.AlertConfig) Provider {
 			Payload: gotifyPayload(priority),
 			Headers: map[string]string{"X-Gotify-Key": cfg.Settings["token"]},
 		}
+	case "opsgenie":
+		priority := "P3"
+		if p, ok := cfg.Settings["priority"]; ok && p != "" {
+			priority = p
+		}
+		apiURL := "https://api.opsgenie.com/v2/alerts"
+		if eu, ok := cfg.Settings["eu"]; ok && eu == "true" {
+			apiURL = "https://api.eu.opsgenie.com/v2/alerts"
+		}
+		return &HTTPProvider{
+			URL:     apiURL,
+			Payload: opsgeniePayload(priority),
+			Headers: map[string]string{"Authorization": "GenieKey " + cfg.Settings["api_key"]},
+		}
 	default:
 		return nil
 	}

internal/alert/alert_test.go

@@ -196,8 +196,76 @@ func TestHTTPProviderGotify(t *testing.T) {
 	}
 }
 
+func TestHTTPProviderOpsgenie(t *testing.T) {
+	var received map[string]any
+	var authHeader string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		authHeader = r.Header.Get("Authorization")
+		json.NewDecoder(r.Body).Decode(&received)
+		w.WriteHeader(202)
+	}))
+	defer srv.Close()
+
+	p := GetProvider(models.AlertConfig{Type: "opsgenie", Settings: map[string]string{
+		"api_key":  "test-genie-key",
+		"priority": "P1",
+	}})
+	hp := p.(*HTTPProvider)
+	hp.URL = srv.URL
+
+	if err := p.Send(context.Background(), "Site Down", "mysite.com is unreachable"); err != nil {
+		t.Fatalf("Send: %v", err)
+	}
+	if authHeader != "GenieKey test-genie-key" {
+		t.Errorf("expected auth 'GenieKey test-genie-key', got '%s'", authHeader)
+	}
+	if received["message"] != "Site Down" {
+		t.Errorf("unexpected message: %v", received["message"])
+	}
+	if received["description"] != "mysite.com is unreachable" {
+		t.Errorf("unexpected description: %v", received["description"])
+	}
+	if received["source"] != "uptop" {
+		t.Errorf("expected source 'uptop', got '%v'", received["source"])
+	}
+	if received["priority"] != "P1" {
+		t.Errorf("expected priority 'P1', got '%v'", received["priority"])
+	}
+}
+
+func TestOpsgenieEUEndpoint(t *testing.T) {
+	p := GetProvider(models.AlertConfig{Type: "opsgenie", Settings: map[string]string{
+		"api_key": "key", "eu": "true",
+	}})
+	hp := p.(*HTTPProvider)
+	if hp.URL != "https://api.eu.opsgenie.com/v2/alerts" {
+		t.Errorf("expected EU URL, got '%s'", hp.URL)
+	}
+}
+
+func TestOpsgenieUSEndpoint(t *testing.T) {
+	p := GetProvider(models.AlertConfig{Type: "opsgenie", Settings: map[string]string{
+		"api_key": "key",
+	}})
+	hp := p.(*HTTPProvider)
+	if hp.URL != "https://api.opsgenie.com/v2/alerts" {
+		t.Errorf("expected US URL, got '%s'", hp.URL)
+	}
+}
+
+func TestLimitMessage(t *testing.T) {
+	short := "short"
+	if got := limitMessage(short, 130); got != short {
+		t.Errorf("expected '%s', got '%s'", short, got)
+	}
+	long := string(make([]byte, 200))
+	if got := limitMessage(long, 130); len(got) != 130 {
+		t.Errorf("expected length 130, got %d", len(got))
+	}
+}
+
 func TestGetProviderNewTypes(t *testing.T) {
-	for _, typ := range []string{"telegram", "pagerduty", "pushover", "gotify"} {
+	for _, typ := range []string{"telegram", "pagerduty", "pushover", "gotify", "opsgenie"} {
 		p := GetProvider(models.AlertConfig{Type: typ, Settings: map[string]string{
 			"token": "x", "chat_id": "1", "routing_key": "k", "user": "u", "url": "http://localhost",
 		}})

internal/cluster/cluster_test.go

@@ -73,7 +73,10 @@ func (m *mockStore) GetPreference(string) (string, error)                   { re
 func (m *mockStore) SetPreference(string, string) error                     { return nil }
 func (m *mockStore) SaveStateChange(int, string, string, string) error      { return nil }
 func (m *mockStore) GetStateChanges(int, int) ([]models.StateChange, error) { return nil, nil }
-func (m *mockStore) Close() error                                           { return nil }
+func (m *mockStore) GetStateChangesSince(int, time.Time) ([]models.StateChange, error) {
+	return nil, nil
+}
+func (m *mockStore) Close() error { return nil }
 
 // --- Cluster Start Tests ---
 

internal/metrics/prometheus_test.go

@@ -71,7 +71,10 @@ func (m *mockStore) GetPreference(string) (string, error)                   { re
 func (m *mockStore) SetPreference(string, string) error                     { return nil }
 func (m *mockStore) SaveStateChange(int, string, string, string) error      { return nil }
 func (m *mockStore) GetStateChanges(int, int) ([]models.StateChange, error) { return nil, nil }
-func (m *mockStore) Close() error                                           { return nil }
+func (m *mockStore) GetStateChangesSince(int, time.Time) ([]models.StateChange, error) {
+	return nil, nil
+}
+func (m *mockStore) Close() error { return nil }
 
 func TestMetricsHandler(t *testing.T) {
 	ms := &mockStore{

internal/monitor/monitor.go

@@ -509,6 +509,7 @@ func (e *Engine) checkPush(site models.Site) {
 	}
 
 	overdue := site.LastCheck.Add(interval)
+	staleMark := overdue.Add(grace / 2)
 	graceEnd := overdue.Add(grace)
 	now := time.Now()
 
@@ -516,6 +517,10 @@ func (e *Engine) checkPush(site models.Site) {
 		if site.Status != "DOWN" {
 			e.handleStatusChange(site, "DOWN", 0, 0, "heartbeat missed")
 		}
+	} else if now.After(staleMark) {
+		if site.Status != "STALE" {
+			e.handleStatusChange(site, "STALE", 0, 0, "heartbeat stale")
+		}
 	} else if now.After(overdue) {
 		if site.Status != "LATE" {
 			e.handleStatusChange(site, "LATE", 0, 0, "heartbeat overdue")
@@ -743,7 +748,11 @@ func (e *Engine) checkGroup(site models.Site) {
 		}
 		if child.Status == "DOWN" || child.Status == "SSL EXP" {
 			status = "DOWN"
-		} else if child.Status == "PENDING" && status != "DOWN" {
+		} else if child.Status == "STALE" && status != "DOWN" {
+			status = "STALE"
+		} else if child.Status == "LATE" && status != "DOWN" && status != "STALE" {
+			status = "LATE"
+		} else if child.Status == "PENDING" && status != "DOWN" && status != "STALE" && status != "LATE" {
 			status = "PENDING"
 		}
 	}
@@ -823,3 +832,11 @@ func (e *Engine) GetStateChanges(siteID int, limit int) []models.StateChange {
 	}
 	return changes
 }
+
+func (e *Engine) GetStateChangesSince(siteID int, since time.Time) []models.StateChange {
+	changes, err := e.db.GetStateChangesSince(siteID, since)
+	if err != nil {
+		return nil
+	}
+	return changes
+}

internal/monitor/monitor_test.go

@@ -80,7 +80,10 @@ func (m *mockStore) GetPreference(string) (string, error)                   { re
 func (m *mockStore) SetPreference(string, string) error                     { return nil }
 func (m *mockStore) SaveStateChange(int, string, string, string) error      { return nil }
 func (m *mockStore) GetStateChanges(int, int) ([]models.StateChange, error) { return nil, nil }
-func (m *mockStore) Close() error                                           { return nil }
+func (m *mockStore) GetStateChangesSince(int, time.Time) ([]models.StateChange, error) {
+	return nil, nil
+}
+func (m *mockStore) Close() error { return nil }
 
 func (m *mockStore) GetAllAlerts() ([]models.AlertConfig, error) {
 	m.mu.Lock()
@@ -571,6 +574,26 @@ func TestCheckPush_OverdueBecomesLate(t *testing.T) {
 	}
 }
 
+func TestCheckPush_OverdueBecomesStale(t *testing.T) {
+	ms := newMockStore()
+	e := newTestEngine(ms)
+	// interval=300, grace=150 (300/2), staleMark=overdue+75
+	// at 380s: past staleMark(375) but before graceEnd(450)
+	site := models.Site{
+		ID: 1, Name: "push", Type: "push", Status: "UP",
+		Interval:  300,
+		LastCheck: time.Now().Add(-380 * time.Second),
+	}
+	injectSite(e, site)
+
+	e.checkPush(site)
+
+	s, _ := getSite(e, 1)
+	if s.Status != "STALE" {
+		t.Errorf("expected STALE when past midpoint of grace, got %s", s.Status)
+	}
+}
+
 func TestCheckPush_WithinDeadline(t *testing.T) {
 	ms := newMockStore()
 	e := newTestEngine(ms)

internal/monitor/sla.go

@@ -0,0 +1,225 @@
+package monitor
+
+import (
+	"time"
+
+	"gitea.lerkolabs.com/lerkolabs/uptop/internal/models"
+)
+
+type SLAReport struct {
+	Window      time.Duration
+	UptimePct   float64
+	Downtime    time.Duration
+	OutageCount int
+	LongestOut  time.Duration
+	MTTR        time.Duration
+	MTBF        time.Duration
+}
+
+func ComputeSLA(changes []models.StateChange, currentStatus string, window time.Duration) SLAReport {
+	now := time.Now()
+	windowStart := now.Add(-window)
+
+	report := SLAReport{Window: window}
+
+	if len(changes) == 0 {
+		if isDown(currentStatus) {
+			report.UptimePct = 0
+			report.Downtime = window
+		} else {
+			report.UptimePct = 100
+		}
+		return report
+	}
+
+	// Sort changes chronologically (they come in DESC from DB).
+	sorted := make([]models.StateChange, len(changes))
+	copy(sorted, changes)
+	for i, j := 0, len(sorted)-1; i < j; i, j = i+1, j-1 {
+		sorted[i], sorted[j] = sorted[j], sorted[i]
+	}
+
+	// Determine status at window start: last transition before or at windowStart.
+	statusAtStart := "UP"
+	for i := len(sorted) - 1; i >= 0; i-- {
+		if !sorted[i].ChangedAt.After(windowStart) {
+			statusAtStart = sorted[i].ToStatus
+			break
+		}
+	}
+
+	var upTime, downTime time.Duration
+	var outages []time.Duration
+	cursor := windowStart
+	wasDown := isDown(statusAtStart)
+
+	if wasDown {
+		report.OutageCount = 1
+	}
+
+	var outageStart time.Time
+	if wasDown {
+		outageStart = windowStart
+	}
+
+	for _, sc := range sorted {
+		if sc.ChangedAt.Before(windowStart) {
+			continue
+		}
+		if sc.ChangedAt.After(now) {
+			break
+		}
+
+		seg := sc.ChangedAt.Sub(cursor)
+		if wasDown {
+			downTime += seg
+		} else {
+			upTime += seg
+		}
+
+		newDown := isDown(sc.ToStatus)
+		if !wasDown && newDown {
+			report.OutageCount++
+			outageStart = sc.ChangedAt
+		}
+		if wasDown && !newDown {
+			dur := sc.ChangedAt.Sub(outageStart)
+			outages = append(outages, dur)
+		}
+
+		wasDown = newDown
+		cursor = sc.ChangedAt
+	}
+
+	// Account for time from last change to now.
+	remaining := now.Sub(cursor)
+	if wasDown {
+		downTime += remaining
+		dur := now.Sub(outageStart)
+		outages = append(outages, dur)
+	} else {
+		upTime += remaining
+	}
+
+	total := upTime + downTime
+	if total > 0 {
+		report.UptimePct = float64(upTime) / float64(total) * 100
+	} else {
+		report.UptimePct = 100
+	}
+	report.Downtime = downTime
+
+	if len(outages) > 0 {
+		var totalOutage time.Duration
+		for _, d := range outages {
+			totalOutage += d
+			if d > report.LongestOut {
+				report.LongestOut = d
+			}
+		}
+		report.MTTR = totalOutage / time.Duration(len(outages))
+	}
+
+	if report.OutageCount > 0 && upTime > 0 {
+		report.MTBF = upTime / time.Duration(report.OutageCount)
+	}
+
+	return report
+}
+
+func ComputeDailyBreakdown(changes []models.StateChange, currentStatus string, days int) []DayReport {
+	now := time.Now()
+	reports := make([]DayReport, days)
+
+	for i := 0; i < days; i++ {
+		dayEnd := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location()).Add(-time.Duration(i) * 24 * time.Hour)
+		if i == 0 {
+			dayEnd = now
+		}
+		dayStart := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location()).Add(-time.Duration(i) * 24 * time.Hour)
+		if i > 0 {
+			dayEnd = dayStart.Add(24 * time.Hour)
+		}
+
+		windowChanges := filterChangesForWindow(changes, dayStart, dayEnd)
+
+		statusAtStart := inferStatusAt(changes, dayStart)
+		sla := computeSLAForWindow(windowChanges, statusAtStart, dayStart, dayEnd)
+
+		reports[i] = DayReport{
+			Date:      dayStart,
+			UptimePct: sla,
+		}
+	}
+
+	return reports
+}
+
+type DayReport struct {
+	Date      time.Time
+	UptimePct float64
+}
+
+func isDown(status string) bool {
+	return status == "DOWN" || status == "SSL EXP"
+}
+
+func filterChangesForWindow(changes []models.StateChange, start, end time.Time) []models.StateChange {
+	var filtered []models.StateChange
+	for _, sc := range changes {
+		if !sc.ChangedAt.Before(start) && sc.ChangedAt.Before(end) {
+			filtered = append(filtered, sc)
+		}
+	}
+	return filtered
+}
+
+func inferStatusAt(changes []models.StateChange, at time.Time) string {
+	// Changes come DESC from DB. Walk backwards to find last change before `at`.
+	for _, sc := range changes {
+		if !sc.ChangedAt.After(at) {
+			return sc.ToStatus
+		}
+	}
+	return "UP"
+}
+
+func computeSLAForWindow(changes []models.StateChange, statusAtStart string, start, end time.Time) float64 {
+	// Sort chronologically.
+	sorted := make([]models.StateChange, len(changes))
+	copy(sorted, changes)
+	for i, j := 0, len(sorted)-1; i < j; i, j = i+1, j-1 {
+		sorted[i], sorted[j] = sorted[j], sorted[i]
+	}
+
+	var upTime, downTime time.Duration
+	cursor := start
+	wasDown := isDown(statusAtStart)
+
+	for _, sc := range sorted {
+		if sc.ChangedAt.Before(start) || !sc.ChangedAt.Before(end) {
+			continue
+		}
+		seg := sc.ChangedAt.Sub(cursor)
+		if wasDown {
+			downTime += seg
+		} else {
+			upTime += seg
+		}
+		wasDown = isDown(sc.ToStatus)
+		cursor = sc.ChangedAt
+	}
+
+	remaining := end.Sub(cursor)
+	if wasDown {
+		downTime += remaining
+	} else {
+		upTime += remaining
+	}
+
+	total := upTime + downTime
+	if total <= 0 {
+		return 100
+	}
+	return float64(upTime) / float64(total) * 100
+}

internal/monitor/sla_test.go

@@ -0,0 +1,165 @@
+package monitor
+
+import (
+	"math"
+	"testing"
+	"time"
+
+	"gitea.lerkolabs.com/lerkolabs/uptop/internal/models"
+)
+
+func TestComputeSLA_NoChanges_CurrentlyUp(t *testing.T) {
+	r := ComputeSLA(nil, "UP", 24*time.Hour)
+	if r.UptimePct != 100 {
+		t.Errorf("expected 100%% uptime, got %.2f%%", r.UptimePct)
+	}
+	if r.Downtime != 0 {
+		t.Errorf("expected 0 downtime, got %v", r.Downtime)
+	}
+}
+
+func TestComputeSLA_NoChanges_CurrentlyDown(t *testing.T) {
+	r := ComputeSLA(nil, "DOWN", 24*time.Hour)
+	if r.UptimePct != 0 {
+		t.Errorf("expected 0%% uptime, got %.2f%%", r.UptimePct)
+	}
+}
+
+func TestComputeSLA_SingleOutage(t *testing.T) {
+	now := time.Now()
+	// DOWN 2 hours ago, recovered 1 hour ago → 1 hour downtime in 24h window
+	changes := []models.StateChange{
+		{ToStatus: "UP", ChangedAt: now.Add(-1 * time.Hour)},
+		{ToStatus: "DOWN", FromStatus: "UP", ChangedAt: now.Add(-2 * time.Hour)},
+	}
+
+	r := ComputeSLA(changes, "UP", 24*time.Hour)
+
+	if r.OutageCount != 1 {
+		t.Errorf("expected 1 outage, got %d", r.OutageCount)
+	}
+
+	expectedDowntime := 1 * time.Hour
+	if absDuration(r.Downtime-expectedDowntime) > time.Minute {
+		t.Errorf("expected ~1h downtime, got %v", r.Downtime)
+	}
+
+	expectedPct := float64(23) / float64(24) * 100
+	if math.Abs(r.UptimePct-expectedPct) > 0.5 {
+		t.Errorf("expected ~%.1f%% uptime, got %.2f%%", expectedPct, r.UptimePct)
+	}
+
+	if r.LongestOut < 55*time.Minute || r.LongestOut > 65*time.Minute {
+		t.Errorf("expected longest outage ~1h, got %v", r.LongestOut)
+	}
+}
+
+func TestComputeSLA_CurrentlyDown(t *testing.T) {
+	now := time.Now()
+	// Went down 3 hours ago, still down
+	changes := []models.StateChange{
+		{ToStatus: "DOWN", FromStatus: "UP", ChangedAt: now.Add(-3 * time.Hour)},
+	}
+
+	r := ComputeSLA(changes, "DOWN", 24*time.Hour)
+
+	if r.OutageCount != 1 {
+		t.Errorf("expected 1 outage, got %d", r.OutageCount)
+	}
+
+	expectedDowntime := 3 * time.Hour
+	if absDuration(r.Downtime-expectedDowntime) > time.Minute {
+		t.Errorf("expected ~3h downtime, got %v", r.Downtime)
+	}
+}
+
+func TestComputeSLA_MultipleOutages(t *testing.T) {
+	now := time.Now()
+	// Two outages: 6h-5h ago and 2h-1h ago
+	changes := []models.StateChange{
+		{ToStatus: "UP", ChangedAt: now.Add(-1 * time.Hour)},
+		{ToStatus: "DOWN", FromStatus: "UP", ChangedAt: now.Add(-2 * time.Hour)},
+		{ToStatus: "UP", ChangedAt: now.Add(-5 * time.Hour)},
+		{ToStatus: "DOWN", FromStatus: "UP", ChangedAt: now.Add(-6 * time.Hour)},
+	}
+
+	r := ComputeSLA(changes, "UP", 24*time.Hour)
+
+	if r.OutageCount != 2 {
+		t.Errorf("expected 2 outages, got %d", r.OutageCount)
+	}
+
+	expectedDowntime := 2 * time.Hour
+	if absDuration(r.Downtime-expectedDowntime) > time.Minute {
+		t.Errorf("expected ~2h downtime, got %v", r.Downtime)
+	}
+
+	if r.MTTR < 55*time.Minute || r.MTTR > 65*time.Minute {
+		t.Errorf("expected MTTR ~1h, got %v", r.MTTR)
+	}
+}
+
+func TestComputeSLA_LateNotDown(t *testing.T) {
+	now := time.Now()
+	// LATE for 2 hours is not downtime
+	changes := []models.StateChange{
+		{ToStatus: "UP", ChangedAt: now.Add(-1 * time.Hour)},
+		{ToStatus: "LATE", FromStatus: "UP", ChangedAt: now.Add(-3 * time.Hour)},
+	}
+
+	r := ComputeSLA(changes, "UP", 24*time.Hour)
+
+	if r.OutageCount != 0 {
+		t.Errorf("expected 0 outages for LATE, got %d", r.OutageCount)
+	}
+	if r.UptimePct != 100 {
+		t.Errorf("expected 100%% uptime (LATE is not down), got %.2f%%", r.UptimePct)
+	}
+}
+
+func TestComputeDailyBreakdown(t *testing.T) {
+	now := time.Now()
+	changes := []models.StateChange{
+		{ToStatus: "UP", ChangedAt: now.Add(-1 * time.Hour)},
+		{ToStatus: "DOWN", FromStatus: "UP", ChangedAt: now.Add(-2 * time.Hour)},
+	}
+
+	days := ComputeDailyBreakdown(changes, "UP", 7)
+
+	if len(days) != 7 {
+		t.Fatalf("expected 7 days, got %d", len(days))
+	}
+
+	// Today should have less than 100% uptime
+	if days[0].UptimePct >= 100 {
+		t.Errorf("expected today < 100%%, got %.2f%%", days[0].UptimePct)
+	}
+}
+
+func TestIsDown(t *testing.T) {
+	if !isDown("DOWN") {
+		t.Error("DOWN should be down")
+	}
+	if !isDown("SSL EXP") {
+		t.Error("SSL EXP should be down")
+	}
+	if isDown("UP") {
+		t.Error("UP should not be down")
+	}
+	if isDown("LATE") {
+		t.Error("LATE should not be down")
+	}
+	if isDown("STALE") {
+		t.Error("STALE should not be down")
+	}
+	if isDown("PENDING") {
+		t.Error("PENDING should not be down")
+	}
+}
+
+func absDuration(d time.Duration) time.Duration {
+	if d < 0 {
+		return -d
+	}
+	return d
+}

internal/server/server_test.go

@@ -82,7 +82,10 @@ func (m *mockStore) GetPreference(string) (string, error)                   { re
 func (m *mockStore) SetPreference(string, string) error                     { return nil }
 func (m *mockStore) SaveStateChange(int, string, string, string) error      { return nil }
 func (m *mockStore) GetStateChanges(int, int) ([]models.StateChange, error) { return nil, nil }
-func (m *mockStore) Close() error                                           { return nil }
+func (m *mockStore) GetStateChangesSince(int, time.Time) ([]models.StateChange, error) {
+	return nil, nil
+}
+func (m *mockStore) Close() error { return nil }
 
 func (m *mockStore) ExportData() (models.Backup, error) {
 	return models.Backup{

internal/store/sqlstore.go

@@ -370,6 +370,23 @@ func (s *SQLStore) GetStateChanges(siteID int, limit int) ([]models.StateChange,
 	return changes, rows.Err()
 }
 
+func (s *SQLStore) GetStateChangesSince(siteID int, since time.Time) ([]models.StateChange, error) {
+	rows, err := s.db.Query(s.q("SELECT id, site_id, from_status, to_status, error_reason, changed_at FROM state_changes WHERE site_id = ? AND changed_at >= ? ORDER BY changed_at DESC"), siteID, since)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var changes []models.StateChange
+	for rows.Next() {
+		var sc models.StateChange
+		if err := rows.Scan(&sc.ID, &sc.SiteID, &sc.FromStatus, &sc.ToStatus, &sc.ErrorReason, &sc.ChangedAt); err != nil {
+			return changes, err
+		}
+		changes = append(changes, sc)
+	}
+	return changes, rows.Err()
+}
+
 func (s *SQLStore) SaveCheck(siteID int, latencyNs int64, isUp bool) error {
 	return s.SaveCheckFromNode(siteID, "", latencyNs, isUp)
 }

internal/store/store.go

@@ -1,6 +1,8 @@
 package store
 
 import (
+	"time"
+
 	"gitea.lerkolabs.com/lerkolabs/uptop/internal/models"
 )
 
@@ -41,6 +43,7 @@ type Store interface {
 	// State Changes
 	SaveStateChange(siteID int, fromStatus, toStatus, errorReason string) error
 	GetStateChanges(siteID int, limit int) ([]models.StateChange, error)
+	GetStateChangesSince(siteID int, since time.Time) ([]models.StateChange, error)
 
 	// Nodes
 	RegisterNode(node models.ProbeNode) error

internal/tui/format.go

@@ -22,6 +22,8 @@ func siteOrder(s models.Site) int {
 	switch s.Status {
 	case "DOWN", "SSL EXP":
 		return 0
+	case "STALE":
+		return 1
 	case "LATE":
 		return 1
 	case "PENDING":
@@ -142,6 +144,8 @@ func fmtStatus(status string, paused bool, inMaint bool, errCategory ErrorCatego
 		return dangerStyle.Render(status)
 	case "LATE":
 		return warnStyle.Render(status)
+	case "STALE":
+		return staleStyle.Render(status)
 	case "PENDING":
 		return subtleStyle.Render(status)
 	default:

internal/tui/tab_alerts.go

@@ -39,6 +39,10 @@ type alertFormData struct {
 	GotifyURL      string
 	GotifyToken    string
 	GotifyPriority string
+	// Opsgenie
+	OpsgenieAPIKey   string
+	OpsgeniePriority string
+	OpsgenieEU       bool
 }
 
 func fmtAlertType(t string) string {
@@ -61,6 +65,8 @@ func fmtAlertType(t string) string {
 		return lipgloss.NewStyle().Foreground(lipgloss.Color("#249DF1")).Render(t)
 	case "gotify":
 		return lipgloss.NewStyle().Foreground(lipgloss.Color("#3F8BBA")).Render(t)
+	case "opsgenie":
+		return lipgloss.NewStyle().Foreground(lipgloss.Color("#2684FF")).Render(t)
 	default:
 		return t
 	}
@@ -108,6 +114,19 @@ func fmtAlertConfig(alert struct {
 			return limitStr(url, 34)
 		}
 		return subtleStyle.Render("—")
+	case "opsgenie":
+		key := alert.Settings["api_key"]
+		if key != "" {
+			masked := key
+			if len(masked) > 8 {
+				masked = masked[:4] + "…" + masked[len(masked)-4:]
+			}
+			if alert.Settings["eu"] == "true" {
+				return limitStr(fmt.Sprintf("EU %s", masked), 34)
+			}
+			return limitStr(masked, 34)
+		}
+		return subtleStyle.Render("—")
 	default:
 		if val, ok := alert.Settings["url"]; ok {
 			return limitStr(val, 34)
@@ -238,6 +257,7 @@ func (m *Model) initAlertHuhForm() tea.Cmd {
 		NtfyPri:           "3",
 		PagerDutySeverity: "critical",
 		GotifyPriority:    "5",
+		OpsgeniePriority:  "P3",
 	}
 
 	if m.editID > 0 {
@@ -275,6 +295,10 @@ func (m *Model) initAlertHuhForm() tea.Cmd {
 					m.alertFormData.GotifyURL = alert.Settings["url"]
 					m.alertFormData.GotifyToken = alert.Settings["token"]
 					m.alertFormData.GotifyPriority = alert.Settings["priority"]
+				case "opsgenie":
+					m.alertFormData.OpsgenieAPIKey = alert.Settings["api_key"]
+					m.alertFormData.OpsgeniePriority = alert.Settings["priority"]
+					m.alertFormData.OpsgenieEU = alert.Settings["eu"] == "true"
 				}
 				break
 			}
@@ -303,6 +327,7 @@ func (m *Model) initAlertHuhForm() tea.Cmd {
 					huh.NewOption("PagerDuty", "pagerduty"),
 					huh.NewOption("Pushover", "pushover"),
 					huh.NewOption("Gotify", "gotify"),
+					huh.NewOption("Opsgenie", "opsgenie"),
 				).Value(&m.alertFormData.AlertType),
 		).Title("Alert Config"),
 		huh.NewGroup(
@@ -410,6 +435,23 @@ func (m *Model) initAlertHuhForm() tea.Cmd {
 		).Title("Gotify Settings").WithHideFunc(func() bool {
 			return m.alertFormData.AlertType != "gotify"
 		}),
+		huh.NewGroup(
+			huh.NewInput().Title("API Key").
+				Placeholder("your-opsgenie-api-key").
+				Value(&m.alertFormData.OpsgenieAPIKey),
+			huh.NewSelect[string]().Title("Priority").
+				Options(
+					huh.NewOption("Critical (P1)", "P1"),
+					huh.NewOption("High (P2)", "P2"),
+					huh.NewOption("Moderate (P3)", "P3"),
+					huh.NewOption("Low (P4)", "P4"),
+					huh.NewOption("Informational (P5)", "P5"),
+				).Value(&m.alertFormData.OpsgeniePriority),
+			huh.NewConfirm().Title("EU Instance?").
+				Value(&m.alertFormData.OpsgenieEU),
+		).Title("Opsgenie Settings").WithHideFunc(func() bool {
+			return m.alertFormData.AlertType != "opsgenie"
+		}),
 	).WithTheme(m.theme.HuhTheme())
 
 	return m.huhForm.Init()
@@ -446,6 +488,12 @@ func (m *Model) submitAlertForm() {
 		settings["url"] = d.GotifyURL
 		settings["token"] = d.GotifyToken
 		settings["priority"] = d.GotifyPriority
+	case "opsgenie":
+		settings["api_key"] = d.OpsgenieAPIKey
+		settings["priority"] = d.OpsgeniePriority
+		if d.OpsgenieEU {
+			settings["eu"] = "true"
+		}
 	default:
 		settings["url"] = d.WebhookURL
 	}

internal/tui/tab_sites.go

@@ -158,7 +158,7 @@ func (m Model) viewSitesTab() string {
 					name = limitStr(name, nameW-2)
 				}
 
-				if (site.Status == "DOWN" || site.Status == "SSL EXP" || site.Status == "LATE") && site.LastError != "" {
+				if (site.Status == "DOWN" || site.Status == "SSL EXP" || site.Status == "LATE" || site.Status == "STALE") && site.LastError != "" {
 					nameLen := len([]rune(name))
 					errSpace := nameW - nameLen - 3
 					if errSpace > 10 {

internal/tui/theme.go

@@ -22,6 +22,7 @@ type Theme struct {
 	// Semantic
 	Success lipgloss.Color
 	Warning lipgloss.Color
+	Stale   lipgloss.Color
 	Danger  lipgloss.Color
 	Info    lipgloss.Color
 	Accent  lipgloss.Color
@@ -54,6 +55,7 @@ var themeFlexokiDark = Theme{
 	Subtle:     "#6F6E69",
 	Success:    "#879A39",
 	Warning:    "#D0A215",
+	Stale:      "#DA702C",
 	Danger:     "#D14D41",
 	Info:       "#4385BE",
 	Accent:     "#3AA99F",
@@ -74,6 +76,7 @@ var themeTokyoNight = Theme{
 	Subtle:     "#565f89",
 	Success:    "#9ece6a",
 	Warning:    "#e0af68",
+	Stale:      "#ff9e64",
 	Danger:     "#f7768e",
 	Info:       "#7aa2f7",
 	Accent:     "#7dcfff",
@@ -94,6 +97,7 @@ var themeGruvbox = Theme{
 	Subtle:     "#7c6f64",
 	Success:    "#b8bb26",
 	Warning:    "#fabd2f",
+	Stale:      "#fe8019",
 	Danger:     "#fb4934",
 	Info:       "#83a598",
 	Accent:     "#8ec07c",
@@ -114,6 +118,7 @@ var themeCatppuccinMocha = Theme{
 	Subtle:     "#6c7086",
 	Success:    "#a6e3a1",
 	Warning:    "#f9e2af",
+	Stale:      "#fab387",
 	Danger:     "#f38ba8",
 	Info:       "#89b4fa",
 	Accent:     "#94e2d5",
@@ -134,6 +139,7 @@ var themeNord = Theme{
 	Subtle:     "#4c566a",
 	Success:    "#a3be8c",
 	Warning:    "#ebcb8b",
+	Stale:      "#d08770",
 	Danger:     "#bf616a",
 	Info:       "#81a1c1",
 	Accent:     "#88c0d0",

internal/tui/tui.go

@@ -20,6 +20,7 @@ var (
 	subtleStyle  lipgloss.Style
 	specialStyle lipgloss.Style
 	warnStyle    lipgloss.Style
+	staleStyle   lipgloss.Style
 	dangerStyle  lipgloss.Style
 	titleStyle   lipgloss.Style
 	activeTab    lipgloss.Style
@@ -30,6 +31,7 @@ func applyTheme(t Theme) {
 	subtleStyle = lipgloss.NewStyle().Foreground(t.Subtle)
 	specialStyle = lipgloss.NewStyle().Foreground(t.Success)
 	warnStyle = lipgloss.NewStyle().Foreground(t.Warning)
+	staleStyle = lipgloss.NewStyle().Foreground(t.Stale)
 	dangerStyle = lipgloss.NewStyle().Foreground(t.Danger)
 	titleStyle = lipgloss.NewStyle().Foreground(t.Accent).Bold(true)
 	activeTab = lipgloss.NewStyle().Border(lipgloss.NormalBorder(), false, false, true, false).BorderForeground(t.Accent).Foreground(t.Accent).Bold(true).Padding(0, 1)
@@ -71,6 +73,7 @@ const (
 	stateConfirmDelete
 	stateFormMaint
 	stateHistory
+	stateSLA
 )
 
 type Model struct {
@@ -96,8 +99,16 @@ type Model struct {
 	historyViewport viewport.Model
 	historyChanges  []models.StateChange
 	historySiteName string
-	isAdmin         bool
-	zones           *zone.Manager
+
+	slaViewport       viewport.Model
+	slaReport         monitor.SLAReport
+	slaDailyBreakdown []monitor.DayReport
+	slaSiteName       string
+	slaSiteID         int
+	slaPeriodIdx      int
+
+	isAdmin bool
+	zones   *zone.Manager
 
 	deleteID   int
 	deleteName string

internal/tui/update.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"time"
 
+	"gitea.lerkolabs.com/lerkolabs/uptop/internal/models"
+	"gitea.lerkolabs.com/lerkolabs/uptop/internal/monitor"
 	"github.com/charmbracelet/bubbles/viewport"
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/huh"
@@ -128,6 +130,8 @@ func (m *Model) handleResize(msg tea.WindowSizeMsg) (tea.Model, tea.Cmd) {
 	m.logViewport.Height = msg.Height - (chromePadV + chromeHeader + chromeGaps + chromeFooter)
 	m.historyViewport.Width = msg.Width - chromePadH
 	m.historyViewport.Height = msg.Height - 10
+	m.slaViewport.Width = msg.Width - chromePadH
+	m.slaViewport.Height = msg.Height - 16
 	return m, tea.ClearScreen
 }
 
@@ -149,6 +153,15 @@ func (m *Model) handleMouse(msg tea.MouseMsg) (tea.Model, tea.Cmd) {
 		}
 		return m, nil
 	}
+	if m.state == stateSLA {
+		switch msg.Button {
+		case tea.MouseButtonWheelUp:
+			m.slaViewport.ScrollUp(3)
+		case tea.MouseButtonWheelDown:
+			m.slaViewport.ScrollDown(3)
+		}
+		return m, nil
+	}
 	if m.state != stateDashboard && m.state != stateLogs && m.state != stateUsers {
 		return m, nil
 	}
@@ -204,6 +217,8 @@ func (m *Model) handleKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 		return m.handleDetailKey(msg)
 	case stateHistory:
 		return m.handleHistoryKey(msg)
+	case stateSLA:
+		return m.handleSLAKey(msg)
 	case stateAlertDetail:
 		return m.handleAlertDetailKey(msg)
 	case stateDashboard, stateLogs, stateUsers:
@@ -261,12 +276,69 @@ func (m *Model) handleDetailKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 			m.historyViewport.GotoTop()
 			m.state = stateHistory
 		}
+	case "s":
+		if m.cursor < len(m.sites) {
+			m.openSLAView(m.sites[m.cursor])
+		}
 	case "q":
 		return m, tea.Quit
 	}
 	return m, nil
 }
 
+func (m *Model) handleSLAKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.String() {
+	case "q", "esc":
+		m.state = stateDetail
+	case "1", "2", "3", "4":
+		idx := int(msg.String()[0]-'0') - 1
+		if idx >= 0 && idx < len(slaPeriods) {
+			m.slaPeriodIdx = idx
+			m.recomputeSLA()
+		}
+	case "up", "k":
+		m.slaViewport.ScrollUp(1)
+	case "down", "j":
+		m.slaViewport.ScrollDown(1)
+	case "pgup":
+		m.slaViewport.HalfPageUp()
+	case "pgdown":
+		m.slaViewport.HalfPageDown()
+	case "ctrl+c":
+		return m, tea.Quit
+	}
+	return m, nil
+}
+
+func (m *Model) openSLAView(site models.Site) {
+	m.slaSiteName = site.Name
+	m.slaSiteID = site.ID
+	m.slaPeriodIdx = 2 // default 30d
+	m.recomputeSLA()
+	m.state = stateSLA
+}
+
+func (m *Model) recomputeSLA() {
+	period := slaPeriods[m.slaPeriodIdx]
+	since := time.Now().Add(-period.duration)
+	changes := m.engine.GetStateChangesSince(m.slaSiteID, since)
+
+	var currentStatus string
+	if m.cursor < len(m.sites) {
+		currentStatus = m.sites[m.cursor].Status
+	}
+
+	m.slaReport = monitor.ComputeSLA(changes, currentStatus, period.duration)
+	m.slaDailyBreakdown = monitor.ComputeDailyBreakdown(changes, currentStatus, period.days)
+
+	m.slaViewport = viewport.New(
+		m.termWidth-chromePadH,
+		m.termHeight-16,
+	)
+	m.slaViewport.SetContent(m.buildSLADailyContent())
+	m.slaViewport.GotoTop()
+}
+
 func (m *Model) handleHistoryKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 	switch msg.String() {
 	case "q", "esc":

internal/tui/view_dashboard.go

@@ -98,6 +98,8 @@ func (m Model) View() string {
 		return m.viewDetailPanel()
 	case stateHistory:
 		return m.viewHistoryPanel()
+	case stateSLA:
+		return m.viewSLAPanel()
 	case stateAlertDetail:
 		return m.viewAlertDetailPanel()
 	default:

internal/tui/view_detail.go

@@ -43,7 +43,7 @@ func (m Model) viewDetailPanel() string {
 	errCat := classifyError(site.LastError, site.Type, site.StatusCode)
 	row("Status", fmtStatus(site.Status, site.Paused, m.isMonitorInMaintenance(site.ID), errCat))
 
-	if (site.Status == "DOWN" || site.Status == "SSL EXP" || site.Status == "LATE") && site.LastError != "" {
+	if (site.Status == "DOWN" || site.Status == "SSL EXP" || site.Status == "LATE" || site.Status == "STALE") && site.LastError != "" {
 		errWidth := m.termWidth - chromePadH - 19
 		if errWidth < 30 {
 			errWidth = 30
@@ -105,6 +105,10 @@ func (m Model) viewDetailPanel() string {
 
 	section("ENDPOINT")
 	row("Type", site.Type)
+	if site.Type == "push" && site.Token != "" {
+		row("Token", site.Token)
+		row("Push", "curl -X POST -H 'Authorization: Bearer "+site.Token+"' <host>/api/push")
+	}
 	if site.URL != "" {
 		row("URL", site.URL)
 	}
@@ -239,7 +243,7 @@ func (m Model) viewDetailPanel() string {
 	}
 
 	b.WriteString("\n\n")
-	b.WriteString(subtleStyle.Render("  [i/Esc] Back  [e] Edit  [h] History  [q] Quit"))
+	b.WriteString(subtleStyle.Render("  [i/Esc] Back  [e] Edit  [h] History  [s] SLA  [q] Quit"))
 
 	return lipgloss.NewStyle().Padding(1, 2).Render(b.String())
 }

internal/tui/view_history.go

@@ -119,9 +119,14 @@ func (m Model) buildHistoryContent() string {
 		ts := sc.ChangedAt.Format("2006-01-02 15:04")
 
 		arrow := subtleStyle.Render(sc.FromStatus) + " → "
-		if sc.ToStatus == "UP" {
+		switch sc.ToStatus {
+		case "UP":
 			arrow += specialStyle.Render(sc.ToStatus)
-		} else {
+		case "LATE":
+			arrow += warnStyle.Render(sc.ToStatus)
+		case "STALE":
+			arrow += staleStyle.Render(sc.ToStatus)
+		default:
 			arrow += dangerStyle.Render(sc.ToStatus)
 		}
 

internal/tui/view_sla.go

@@ -0,0 +1,141 @@
+package tui
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"time"
+
+	"github.com/charmbracelet/lipgloss"
+)
+
+var slaPeriods = []struct {
+	label    string
+	key      string
+	duration time.Duration
+	days     int
+}{
+	{"24h", "1", 24 * time.Hour, 1},
+	{"7d", "2", 7 * 24 * time.Hour, 7},
+	{"30d", "3", 30 * 24 * time.Hour, 30},
+	{"90d", "4", 90 * 24 * time.Hour, 90},
+}
+
+func (m Model) viewSLAPanel() string {
+	var b strings.Builder
+
+	header := "  " + titleStyle.Render("SLA REPORT: "+m.slaSiteName)
+	header += "  " + subtleStyle.Render("[q] Back")
+	b.WriteString(header + "\n")
+
+	divWidth := m.termWidth - chromePadH - 4
+	if divWidth < 40 {
+		divWidth = 40
+	}
+	b.WriteString("  " + subtleStyle.Render(strings.Repeat("─", divWidth)) + "\n")
+
+	period := slaPeriods[m.slaPeriodIdx]
+	b.WriteString("  " + subtleStyle.Render("Period: Last "+period.label) + "\n\n")
+
+	r := m.slaReport
+
+	// Uptime bar
+	barWidth := divWidth - 30
+	if barWidth < 10 {
+		barWidth = 10
+	}
+	bar := uptimeBar(r.UptimePct, barWidth)
+	uptimeColor := specialStyle
+	if r.UptimePct < 99.9 {
+		uptimeColor = warnStyle
+	}
+	if r.UptimePct < 99.0 {
+		uptimeColor = dangerStyle
+	}
+	fmt.Fprintf(&b, "  %-14s %s  %s\n", subtleStyle.Render("Uptime"), uptimeColor.Render(fmt.Sprintf("%s%%", fmtPct(r.UptimePct))), bar)
+	fmt.Fprintf(&b, "  %-14s %s\n", subtleStyle.Render("Downtime"), fmtDuration(r.Downtime))
+	fmt.Fprintf(&b, "  %-14s %d\n", subtleStyle.Render("Outages"), r.OutageCount)
+
+	if r.OutageCount > 0 {
+		fmt.Fprintf(&b, "  %-14s %s\n", subtleStyle.Render("Longest"), fmtDuration(r.LongestOut))
+		fmt.Fprintf(&b, "  %-14s %s\n", subtleStyle.Render("MTTR"), fmtDuration(r.MTTR))
+		fmt.Fprintf(&b, "  %-14s %s\n", subtleStyle.Render("MTBF"), fmtDuration(r.MTBF))
+	}
+
+	b.WriteString("\n  " + subtleStyle.Render(strings.Repeat("─", divWidth)) + "\n")
+
+	if len(m.slaDailyBreakdown) > 0 {
+		b.WriteString(m.slaViewport.View())
+	}
+
+	b.WriteString("\n  " + subtleStyle.Render(strings.Repeat("─", divWidth)) + "\n")
+
+	var keys []string
+	for i, p := range slaPeriods {
+		label := fmt.Sprintf("[%s] %s", p.key, p.label)
+		if i == m.slaPeriodIdx {
+			keys = append(keys, titleStyle.Render(label))
+		} else {
+			keys = append(keys, subtleStyle.Render(label))
+		}
+	}
+	b.WriteString("  " + strings.Join(keys, "  "))
+	b.WriteString("  " + subtleStyle.Render("[j/k/↑/↓] Scroll"))
+
+	return lipgloss.NewStyle().Padding(1, 2).Render(b.String())
+}
+
+func (m Model) buildSLADailyContent() string {
+	var b strings.Builder
+
+	barWidth := m.termWidth - chromePadH - 30
+	if barWidth < 10 {
+		barWidth = 10
+	}
+
+	b.WriteString("  " + subtleStyle.Render("DAILY BREAKDOWN") + "\n")
+	for _, day := range m.slaDailyBreakdown {
+		dateStr := day.Date.Format("Jan 02")
+		bar := uptimeBar(day.UptimePct, barWidth)
+		pctStr := fmtPct(day.UptimePct) + "%"
+
+		color := specialStyle
+		if day.UptimePct < 99.9 {
+			color = warnStyle
+		}
+		if day.UptimePct < 99.0 {
+			color = dangerStyle
+		}
+
+		fmt.Fprintf(&b, "  %-8s %s  %s\n", subtleStyle.Render(dateStr), bar, color.Render(pctStr))
+	}
+
+	return b.String()
+}
+
+func uptimeBar(pct float64, width int) string {
+	filled := int(math.Round(pct / 100 * float64(width)))
+	if filled > width {
+		filled = width
+	}
+	if filled < 0 {
+		filled = 0
+	}
+	empty := width - filled
+
+	bar := specialStyle.Render(strings.Repeat("█", filled))
+	if empty > 0 {
+		bar += subtleStyle.Render(strings.Repeat("░", empty))
+	}
+	return bar
+}
+
+func fmtPct(pct float64) string {
+	if pct == 100 {
+		return "100.00"
+	}
+	if pct >= 99.99 {
+		return fmt.Sprintf("%.3f", pct)
+	}
+	return fmt.Sprintf("%.2f", pct)
+}