wupbro 0.1.2__py3-none-any.whl

wupbro/__init__.py

@@ -0,0 +1,7 @@
+"""WUP Browser Dashboard — FastAPI backend for WUP regression watcher."""
+
+__version__ = "0.1.2"
+
+from .main import create_app, app
+
+__all__ = ["create_app", "app", "__version__"]

wupbro/__main__.py

@@ -0,0 +1,21 @@
+"""CLI entry-point: `python -m wupbro` or `wupbro`."""
+
+from __future__ import annotations
+
+import argparse
+import os
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="wupbro", description="WUP Browser Dashboard")
+    parser.add_argument("--host", default=os.environ.get("WUPBRO_HOST", "0.0.0.0"))
+    parser.add_argument("--port", type=int, default=int(os.environ.get("WUPBRO_PORT", "8000")))
+    parser.add_argument("--reload", action="store_true", help="auto-reload (dev)")
+    args = parser.parse_args()
+
+    import uvicorn
+    uvicorn.run("wupbro.main:app", host=args.host, port=args.port, reload=args.reload)
+
+
+if __name__ == "__main__":
+    main()

wupbro/main.py

@@ -0,0 +1,44 @@
+"""FastAPI entry-point for wupbro."""
+
+from __future__ import annotations
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from . import __version__
+from .routers import dashboard, drivers, events
+
+
+def create_app() -> FastAPI:
+    app = FastAPI(
+        title="WUP Browser Dashboard",
+        version=__version__,
+        description=(
+            "Backend for the WUP regression watcher. Receives events from "
+            "WUP agents (REGRESSION, PASS, ANOMALY, VISUAL_DIFF, HEALTH_TRANSITION), "
+            "exposes drivers (DOM diff, browserless, anomaly), and serves a dashboard."
+        ),
+    )
+
+    # Permissive CORS — dashboard usually served from same origin, but agents
+    # may live elsewhere. Tighten in production.
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    app.include_router(events.router)
+    app.include_router(drivers.router)
+    app.include_router(dashboard.router)
+
+    @app.get("/healthz", tags=["meta"])
+    async def healthz():
+        return {"ok": True, "version": __version__}
+
+    return app
+
+
+# Module-level instance for `uvicorn wupbro.main:app`
+app = create_app()

wupbro/models.py

@@ -0,0 +1,59 @@
+"""Pydantic models for wupbro events and driver requests."""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, List, Literal, Optional
+
+from pydantic import BaseModel, Field
+
+
+EventType = Literal[
+    "REGRESSION",
+    "PASS",
+    "ANOMALY",
+    "VISUAL_DIFF",
+    "HEALTH_TRANSITION",
+]
+
+
+class Event(BaseModel):
+    """Generic WUP event posted by an agent."""
+
+    type: EventType
+    service: Optional[str] = None
+    file: Optional[str] = None
+    endpoint: Optional[str] = None
+    url: Optional[str] = None
+    status: Optional[str] = None
+    stage: Optional[str] = None
+    reason: Optional[str] = None
+    diff: Optional[Dict[str, Any]] = None
+    timestamp: int = Field(default_factory=lambda: int(time.time()))
+
+    # Forward-compat: allow extra keys to land in `extra`
+    model_config = {"extra": "allow"}
+
+
+class EventList(BaseModel):
+    items: List[Event]
+    total: int
+
+
+class DomDiffRequest(BaseModel):
+    url: str
+    service: str = "default"
+    max_depth: int = 10
+
+
+class ScreenshotRequest(BaseModel):
+    url: str
+    full_page: bool = True
+
+
+class AnomalyReport(BaseModel):
+    service: str
+    metric: str
+    value: float
+    threshold: float
+    timestamp: int = Field(default_factory=lambda: int(time.time()))

wupbro/routers/__init__.py

@@ -0,0 +1 @@
+"""Routers for wupbro."""

wupbro/routers/dashboard.py

@@ -0,0 +1,24 @@
+"""Minimal HTML dashboard rendered with Jinja2 (no React required)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import APIRouter, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+
+router = APIRouter(tags=["dashboard"])
+
+_TEMPLATES_DIR = Path(__file__).resolve().parent.parent / "templates"
+templates = Jinja2Templates(directory=str(_TEMPLATES_DIR))
+
+
+@router.get("/", response_class=HTMLResponse)
+async def root(request: Request) -> HTMLResponse:
+    return templates.TemplateResponse(request, "index.html")
+
+
+@router.get("/dashboard", response_class=HTMLResponse)
+async def dashboard(request: Request) -> HTMLResponse:
+    return templates.TemplateResponse(request, "index.html")

wupbro/routers/drivers.py

@@ -0,0 +1,129 @@
+"""Driver endpoints exposed by wupbro.
+
+  - /drivers/dom-diff/capture  → uses wup.visual_diff.VisualDiffer (Playwright)
+  - /drivers/browserless/screenshot → proxies a browserless container
+  - /drivers/anomaly/report    → records anomaly metrics into the event store
+
+Each driver degrades gracefully if its underlying dependency is missing.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import Any, Dict, Optional
+
+import httpx
+from fastapi import APIRouter, Depends, HTTPException
+
+from ..models import AnomalyReport, DomDiffRequest, ScreenshotRequest, Event
+from ..storage import EventStore, get_default_store
+
+router = APIRouter(prefix="/drivers", tags=["drivers"])
+
+
+def _store() -> EventStore:
+    return get_default_store()
+
+
+# ---------------------------------------------------------------------------
+# DOM diff driver — relies on the wup package being installed alongside.
+# ---------------------------------------------------------------------------
+
+@router.post("/dom-diff/capture")
+async def dom_diff_capture(req: DomDiffRequest,
+                           store: EventStore = Depends(_store)) -> Dict[str, Any]:
+    """
+    Trigger a one-shot DOM snapshot + diff against the previous snapshot.
+
+    Requires: `pip install wup playwright` and `playwright install chromium`.
+    """
+    try:
+        from wup.models.config import VisualDiffConfig
+        from wup.visual_diff import VisualDiffer
+    except ImportError as exc:
+        raise HTTPException(503, detail=f"wup package not available: {exc}")
+
+    cfg = VisualDiffConfig(
+        enabled=True,
+        pages=[req.url],
+        pages_from_endpoints=False,
+        max_depth=req.max_depth,
+        delay_seconds=0,
+    )
+    differ = VisualDiffer(os.getcwd(), cfg)
+    results = await differ.run_for_service(req.service, [])
+
+    # forward each diff to the event store
+    for r in results:
+        store.add(Event(
+            type="VISUAL_DIFF",
+            service=req.service,
+            url=r.get("url"),
+            diff=r.get("diff"),
+            timestamp=int(time.time()),
+        ))
+    return {"results": results}
+
+
+# ---------------------------------------------------------------------------
+# Browserless proxy — POSTs to an external browserless/chrome container.
+# ---------------------------------------------------------------------------
+
+@router.post("/browserless/screenshot")
+async def browserless_screenshot(req: ScreenshotRequest) -> Dict[str, Any]:
+    """
+    Proxy to a `browserless/chrome` container.
+
+    Set BROWSERLESS_URL (default http://browserless:3000) for the upstream.
+    """
+    upstream = os.environ.get("BROWSERLESS_URL", "http://browserless:3000")
+    body = {"url": req.url, "options": {"fullPage": req.full_page}}
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.post(f"{upstream}/screenshot", json=body)
+        if resp.status_code >= 400:
+            raise HTTPException(resp.status_code, detail=resp.text)
+        return {
+            "upstream": upstream,
+            "status": resp.status_code,
+            "content_type": resp.headers.get("content-type", ""),
+            "size_bytes": len(resp.content),
+        }
+    except httpx.HTTPError as exc:
+        raise HTTPException(503, detail=f"browserless unreachable: {exc}")
+
+
+# ---------------------------------------------------------------------------
+# Anomaly driver — record numeric anomalies as events.
+# ---------------------------------------------------------------------------
+
+@router.post("/anomaly/report", status_code=201)
+async def anomaly_report(report: AnomalyReport,
+                         store: EventStore = Depends(_store)) -> Dict[str, Any]:
+    store.add(Event(
+        type="ANOMALY",
+        service=report.service,
+        status="anomaly",
+        reason=f"{report.metric}={report.value} > threshold={report.threshold}",
+        timestamp=report.timestamp,
+    ))
+    return {"accepted": True, "service": report.service}
+
+
+@router.get("/health")
+async def driver_health() -> Dict[str, Any]:
+    """Best-effort capability discovery."""
+    caps: Dict[str, bool] = {"events": True, "anomaly": True}
+    try:
+        import wup.visual_diff  # noqa: F401
+        caps["dom_diff"] = True
+    except ImportError:
+        caps["dom_diff"] = False
+    try:
+        import playwright  # noqa: F401
+        caps["playwright"] = True
+    except ImportError:
+        caps["playwright"] = False
+    caps["browserless_url"] = os.environ.get("BROWSERLESS_URL", "")
+    return caps

wupbro/routers/events.py

@@ -0,0 +1,48 @@
+"""POST /events — receive events from WUP agents.
+
+GET /events — list recent events (filterable by type/service).
+GET /events/stats — aggregate counts by type.
+DELETE /events — clear the store (admin/debug).
+"""
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+from fastapi import APIRouter, Query, Depends
+
+from ..models import Event, EventList
+from ..storage import EventStore, get_default_store
+
+router = APIRouter(prefix="/events", tags=["events"])
+
+
+def _store() -> EventStore:
+    return get_default_store()
+
+
+@router.post("", status_code=201)
+async def post_event(event: Event, store: EventStore = Depends(_store)) -> dict:
+    store.add(event)
+    return {"accepted": True, "type": event.type, "timestamp": event.timestamp}
+
+
+@router.get("", response_model=EventList)
+async def list_events(
+    type: Optional[str] = Query(None, description="Filter by event type"),
+    service: Optional[str] = Query(None, description="Filter by service name"),
+    limit: int = Query(100, ge=1, le=1000),
+    store: EventStore = Depends(_store),
+) -> EventList:
+    items = store.list(type_filter=type, service_filter=service, limit=limit)
+    return EventList(items=items, total=len(items))
+
+
+@router.get("/stats")
+async def event_stats(store: EventStore = Depends(_store)) -> dict:
+    return store.stats()
+
+
+@router.delete("", status_code=204)
+async def clear_events(store: EventStore = Depends(_store)) -> None:
+    store.clear()

wupbro/storage.py

@@ -0,0 +1,110 @@
+"""In-memory + JSONL persistence for WUP events.
+
+The storage layer is intentionally simple: events are kept in memory
+(deque, capped) AND appended to a JSONL file for persistence between
+restarts. Suitable for a single-node dashboard.
+"""
+
+from __future__ import annotations
+
+import json
+import threading
+from collections import deque
+from pathlib import Path
+from typing import Deque, Iterable, List, Optional
+
+from .models import Event
+
+
+class EventStore:
+    """Thread-safe ring buffer + JSONL persistence."""
+
+    def __init__(self, jsonl_path: Optional[Path] = None, capacity: int = 1000):
+        self.capacity = capacity
+        self.events: Deque[Event] = deque(maxlen=capacity)
+        self.jsonl_path = jsonl_path
+        self._lock = threading.Lock()
+        self._seq = 0  # monotonic insertion counter (tiebreaker for sort)
+        self._seq_by_id: dict = {}
+        if self.jsonl_path:
+            self.jsonl_path.parent.mkdir(parents=True, exist_ok=True)
+            self._load_existing()
+
+    def _load_existing(self) -> None:
+        if not self.jsonl_path or not self.jsonl_path.exists():
+            return
+        try:
+            with self.jsonl_path.open("r", encoding="utf-8") as fh:
+                for line in fh:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        self.events.append(Event.model_validate_json(line))
+                    except Exception:
+                        continue
+        except OSError:
+            pass
+
+    def add(self, event: Event) -> None:
+        with self._lock:
+            self._seq += 1
+            self._seq_by_id[id(event)] = self._seq
+            self.events.append(event)
+            if self.jsonl_path:
+                try:
+                    with self.jsonl_path.open("a", encoding="utf-8") as fh:
+                        fh.write(event.model_dump_json() + "\n")
+                except OSError:
+                    pass
+
+    def list(
+        self,
+        type_filter: Optional[str] = None,
+        service_filter: Optional[str] = None,
+        limit: int = 100,
+    ) -> List[Event]:
+        with self._lock:
+            items: List[Event] = list(self.events)
+            seq_map = dict(self._seq_by_id)
+        if type_filter:
+            items = [e for e in items if e.type == type_filter]
+        if service_filter:
+            items = [e for e in items if e.service == service_filter]
+        # newest first: primary key timestamp, tiebreaker insertion sequence
+        items.sort(key=lambda e: (e.timestamp, seq_map.get(id(e), 0)), reverse=True)
+        return items[:limit]
+
+    def clear(self) -> None:
+        with self._lock:
+            self.events.clear()
+            self._seq_by_id.clear()
+            self._seq = 0
+            if self.jsonl_path and self.jsonl_path.exists():
+                try:
+                    self.jsonl_path.unlink()
+                except OSError:
+                    pass
+
+    def stats(self) -> dict:
+        with self._lock:
+            counts: dict = {}
+            for e in self.events:
+                counts[e.type] = counts.get(e.type, 0) + 1
+            return {"total": len(self.events), "by_type": counts}
+
+
+# Module-level default store (used by routers); tests can replace via dependency override.
+_default_store: Optional[EventStore] = None
+
+
+def get_default_store() -> EventStore:
+    global _default_store
+    if _default_store is None:
+        _default_store = EventStore(jsonl_path=Path(".wupbro/events.jsonl"))
+    return _default_store
+
+
+def set_default_store(store: EventStore) -> None:
+    global _default_store
+    _default_store = store

wupbro/templates/index.html

@@ -0,0 +1,182 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>WUP Dashboard</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <style>
+    :root {
+      --bg: #0d1117;
+      --panel: #161b22;
+      --border: #30363d;
+      --text: #e6edf3;
+      --muted: #7d8590;
+      --green: #3fb950;
+      --red: #f85149;
+      --yellow: #d29922;
+      --blue: #58a6ff;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+      background: var(--bg);
+      color: var(--text);
+    }
+    header {
+      padding: 16px 24px;
+      border-bottom: 1px solid var(--border);
+      display: flex;
+      align-items: center;
+      gap: 16px;
+    }
+    header h1 { font-size: 18px; margin: 0; }
+    header .badge {
+      padding: 2px 8px; border-radius: 12px; background: var(--panel);
+      color: var(--muted); font-size: 12px;
+    }
+    main { padding: 24px; max-width: 1200px; margin: 0 auto; }
+    .stats { display: flex; gap: 12px; margin-bottom: 24px; flex-wrap: wrap; }
+    .stat {
+      flex: 1; min-width: 120px;
+      padding: 16px; background: var(--panel); border: 1px solid var(--border);
+      border-radius: 8px;
+    }
+    .stat .label { color: var(--muted); font-size: 12px; text-transform: uppercase; }
+    .stat .value { font-size: 24px; font-weight: 600; margin-top: 4px; }
+    .stat.regression .value { color: var(--red); }
+    .stat.pass .value { color: var(--green); }
+    .stat.anomaly .value { color: var(--yellow); }
+    .stat.diff .value { color: var(--blue); }
+
+    table { width: 100%; border-collapse: collapse; background: var(--panel); border-radius: 8px; overflow: hidden; }
+    th, td { padding: 10px 12px; text-align: left; border-bottom: 1px solid var(--border); font-size: 13px; }
+    th { background: #1c2129; color: var(--muted); font-weight: 500; text-transform: uppercase; font-size: 11px; }
+    tr:last-child td { border-bottom: none; }
+
+    .type-tag {
+      padding: 2px 8px; border-radius: 4px; font-size: 11px; font-weight: 500;
+      display: inline-block; min-width: 70px; text-align: center;
+    }
+    .type-REGRESSION { background: rgba(248,81,73,.15); color: var(--red); }
+    .type-PASS { background: rgba(63,185,80,.15); color: var(--green); }
+    .type-ANOMALY { background: rgba(210,153,34,.15); color: var(--yellow); }
+    .type-VISUAL_DIFF { background: rgba(88,166,255,.15); color: var(--blue); }
+    .type-HEALTH_TRANSITION { background: rgba(125,133,144,.15); color: var(--muted); }
+
+    .controls { display: flex; gap: 8px; margin-bottom: 12px; }
+    button, select {
+      background: var(--panel); color: var(--text); border: 1px solid var(--border);
+      padding: 6px 12px; border-radius: 6px; font-size: 13px; cursor: pointer;
+    }
+    button:hover { background: #1c2129; }
+    .muted { color: var(--muted); }
+    .empty { text-align: center; padding: 40px; color: var(--muted); }
+  </style>
+</head>
+<body>
+  <header>
+    <h1>🔬 WUP Dashboard</h1>
+    <span class="badge" id="status">connecting…</span>
+    <span class="badge muted" id="last-update">—</span>
+  </header>
+  <main>
+    <div class="stats" id="stats"></div>
+    <div class="controls">
+      <select id="filter-type">
+        <option value="">All types</option>
+        <option value="REGRESSION">Regression</option>
+        <option value="PASS">Pass</option>
+        <option value="ANOMALY">Anomaly</option>
+        <option value="VISUAL_DIFF">Visual diff</option>
+        <option value="HEALTH_TRANSITION">Health transition</option>
+      </select>
+      <button onclick="refresh()">↻ Refresh</button>
+      <button onclick="clearAll()" style="color: var(--red)">⌫ Clear</button>
+    </div>
+    <table>
+      <thead>
+        <tr>
+          <th>Time</th><th>Type</th><th>Service</th>
+          <th>Endpoint / URL</th><th>Status</th><th>Reason</th>
+        </tr>
+      </thead>
+      <tbody id="rows">
+        <tr><td colspan="6" class="empty">Loading…</td></tr>
+      </tbody>
+    </table>
+  </main>
+
+<script>
+const fmtTime = (ts) => new Date(ts * 1000).toLocaleTimeString();
+
+async function fetchEvents() {
+  const filter = document.getElementById("filter-type").value;
+  const url = filter ? `/events?type=${filter}&limit=200` : "/events?limit=200";
+  const r = await fetch(url);
+  if (!r.ok) throw new Error(`HTTP ${r.status}`);
+  return r.json();
+}
+
+async function fetchStats() {
+  const r = await fetch("/events/stats");
+  return r.json();
+}
+
+function renderStats(stats) {
+  const types = ["REGRESSION", "PASS", "ANOMALY", "VISUAL_DIFF", "HEALTH_TRANSITION"];
+  const cls = { REGRESSION: "regression", PASS: "pass", ANOMALY: "anomaly", VISUAL_DIFF: "diff", HEALTH_TRANSITION: "" };
+  const labels = { REGRESSION: "Regressions", PASS: "Passes", ANOMALY: "Anomalies", VISUAL_DIFF: "Visual diffs", HEALTH_TRANSITION: "Health" };
+  const container = document.getElementById("stats");
+  const totalCard = `<div class="stat"><div class="label">Total events</div><div class="value">${stats.total}</div></div>`;
+  const cards = types.map(t => {
+    const v = (stats.by_type && stats.by_type[t]) || 0;
+    return `<div class="stat ${cls[t] || ""}"><div class="label">${labels[t]}</div><div class="value">${v}</div></div>`;
+  });
+  container.innerHTML = totalCard + cards.join("");
+}
+
+function renderRows(items) {
+  const tbody = document.getElementById("rows");
+  if (!items.length) {
+    tbody.innerHTML = '<tr><td colspan="6" class="empty">No events yet</td></tr>';
+    return;
+  }
+  tbody.innerHTML = items.map(e => `
+    <tr>
+      <td class="muted">${fmtTime(e.timestamp)}</td>
+      <td><span class="type-tag type-${e.type}">${e.type}</span></td>
+      <td>${e.service || "—"}</td>
+      <td class="muted">${e.endpoint || e.url || "—"}</td>
+      <td>${e.status || "—"}</td>
+      <td class="muted">${e.reason || "—"}</td>
+    </tr>
+  `).join("");
+}
+
+async function refresh() {
+  try {
+    const [events, stats] = await Promise.all([fetchEvents(), fetchStats()]);
+    renderStats(stats);
+    renderRows(events.items);
+    document.getElementById("status").textContent = "live";
+    document.getElementById("status").style.color = "var(--green)";
+    document.getElementById("last-update").textContent = "updated " + new Date().toLocaleTimeString();
+  } catch (err) {
+    document.getElementById("status").textContent = "offline";
+    document.getElementById("status").style.color = "var(--red)";
+  }
+}
+
+async function clearAll() {
+  if (!confirm("Clear all events?")) return;
+  await fetch("/events", { method: "DELETE" });
+  refresh();
+}
+
+document.getElementById("filter-type").addEventListener("change", refresh);
+refresh();
+setInterval(refresh, 3000);
+</script>
+</body>
+</html>

wupbro-0.1.2.dist-info/METADATA

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: wupbro
+Version: 0.1.2
+Summary: WUP Browser Dashboard — FastAPI backend for WUP regression watcher
+Author: WUP contributors
+Author-email: Tom Sapletta <tom@sapletta.com>
+License: Apache-2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn[standard]>=0.27
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.0
+Requires-Dist: jinja2>=3.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+Requires-Dist: goal>=2.1.0; extra == "dev"
+Requires-Dist: costs>=0.1.20; extra == "dev"
+Requires-Dist: pfix>=0.1.60; extra == "dev"
+
+# wupbro
+
+FastAPI backend + minimal HTML dashboard for the WUP regression watcher.
+
+## Architecture
+
+```
+┌──────────────────────┐   POST /events    ┌──────────────────────┐
+│  WUP agent (shell)   │ ───────────────▶  │  wupbro (FastAPI)   │
+│  - file watcher      │                   │  - /events (sink)    │
+│  - testql runner     │                   │  - /drivers/*        │
+│  - visual diff       │                   │  - /dashboard (UI)   │
+└──────────────────────┘                   └──────────────────────┘
+                                                      │
+                                                      ▼
+                                            ┌─────────────────┐
+                                            │ Browser UI      │
+                                            │ (auto-refresh)  │
+                                            └─────────────────┘
+```
+
+## Endpoints
+
+| Path                              | Method | Purpose                                     |
+|-----------------------------------|--------|---------------------------------------------|
+| `/events`                         | POST   | Receive event from a WUP agent              |
+| `/events`                         | GET    | List recent events (filter by type/service) |
+| `/events/stats`                   | GET    | Aggregate counts by type                    |
+| `/events`                         | DELETE | Clear store (admin/debug)                   |
+| `/drivers/dom-diff/capture`       | POST   | One-shot Playwright DOM snapshot + diff     |
+| `/drivers/browserless/screenshot` | POST   | Proxy to a `browserless/chrome` container   |
+| `/drivers/anomaly/report`         | POST   | Record numeric anomaly as ANOMALY event     |
+| `/drivers/health`                 | GET    | Driver capability discovery                 |
+| `/`, `/dashboard`                 | GET    | HTML dashboard                              |
+| `/healthz`                        | GET    | Liveness probe                              |
+| `/openapi.json`, `/docs`          | GET    | OpenAPI spec + Swagger UI                   |
+
+## Event types
+
+`REGRESSION`, `PASS`, `ANOMALY`, `VISUAL_DIFF`, `HEALTH_TRANSITION`.
+
+Schema (Pydantic):
+
+```json
+{
+  "type": "REGRESSION",
+  "service": "users-web",
+  "file": "app/users/routes.py",
+  "endpoint": "/api/users",
+  "status": "fail",
+  "stage": "quick",
+  "reason": "TestQL exit code 1",
+  "timestamp": 1730000000
+}
+```
+
+Extra fields are preserved via `model_config = {"extra": "allow"}`.
+
+## Run
+
+```bash
+# Install
+pip install -e wupbro/
+
+# Dev server (auto-reload)
+wupbro --reload --port 8000
+
+# Or directly
+uvicorn wupbro.main:app --host 0.0.0.0 --port 8000 --reload
+```
+
+Dashboard: <http://localhost:8000/>
+
+OpenAPI docs: <http://localhost:8000/docs>
+
+## Configure WUP agent to send events
+
+In your `wup.yaml`:
+
+```yaml
+web:
+  enabled: true
+  endpoint: "http://localhost:8000"
+  endpoint_env: "WUPBRO_ENDPOINT"   # fallback if endpoint is empty
+  timeout_s: 2.0                     # short — must not block watcher
+  api_key: ""                        # optional bearer token
+```
+
+Or via environment variable:
+
+```bash
+export WUPBRO_ENDPOINT=http://localhost:8000
+wup watch . --mode testql
+```
+
+The agent will POST events fire-and-forget on:
+
+- service health transitions (up ↔ down)
+- regressions (when TestQL fails)
+- visual DOM diffs (when significant changes detected)
+
+## Browserless integration
+
+```bash
+docker run -d --name browserless -p 3000:3000 browserless/chrome
+export BROWSERLESS_URL=http://localhost:3000
+wup-web
+```
+
+Then:
+
+```bash
+curl -X POST http://localhost:8000/drivers/browserless/screenshot \
+  -H "Content-Type: application/json" \
+  -d '{"url": "http://example.com", "full_page": true}'
+```
+
+## Storage
+
+Events are kept in an in-memory ring buffer (capacity 1000) and persisted to `.wupbro/events.jsonl` for restart durability.
+
+## Tests
+
+```bash
+PYTHONPATH=wupbro python3 -m pytest wupbro/tests/ -v
+```
+
+17 tests covering events router, drivers (anomaly, browserless, dom-diff, health), dashboard HTML, OpenAPI schema.
+
+## License
+
+Licensed under Apache-2.0.

wupbro-0.1.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+wupbro/__init__.py,sha256=zCuE1TMepCmf2qAt_RQkYCbeFc0JbHTVrnXtxM-94Ss,182
+wupbro/__main__.py,sha256=oXLjPSkNX7vbOXzNRukO_VXaF6_zCy_hVEf-R6XQaM0,670
+wupbro/main.py,sha256=6ZtBJD3xchb7kTcGNovP5hgUUq9JcAf-vVrjp2fw9hY,1236
+wupbro/models.py,sha256=cayG7Iz2h29ln_vcMRdH9gp4ikKCx4CNALCl5-RISz8,1269
+wupbro/storage.py,sha256=2MjZCoazshSaiVX0_oQYs_tR8yCtOx5aB6Emtjsy-s4,3675
+wupbro/routers/__init__.py,sha256=nqd9_ug9P9oE4E50eIn6fD6vMdO-pFuDuhe28XXiPDk,26
+wupbro/routers/dashboard.py,sha256=5qbBsigVdA9psL03n0LvUSSk1IN_qtGiiU1WxAErFag,765
+wupbro/routers/drivers.py,sha256=GiJqBHJTNP6cpau2egyzQxvf70xagGQfA-lMrCYFvzY,4564
+wupbro/routers/events.py,sha256=fuK8IzIYQQoyi2kHfAxn6ACZoXv3M-v7jepNkb67KeU,1458
+wupbro/templates/index.html,sha256=Vs0Ufm6UCQtaT_BE0JNoWMCRjxFXISLNIhCV548cdGc,6759
+wupbro-0.1.2.dist-info/METADATA,sha256=DiBad3BoYOm0XgujRnRIv7PqU80nngRgRodtbAVvnfA,5182
+wupbro-0.1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+wupbro-0.1.2.dist-info/entry_points.txt,sha256=ZoiFlqDNWFI0Or8T0csnW80lD77Z17DBJYzgh3gVqgg,48
+wupbro-0.1.2.dist-info/top_level.txt,sha256=TvEt3F9VMcrEO6LmPEPiKnIqaEcvGhJUTpeGDnwB_Gw,7
+wupbro-0.1.2.dist-info/RECORD,,

wupbro-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

wupbro-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+wupbro = wupbro.__main__:main

wupbro-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+wupbro