agentmetry 0.4.0__py3-none-any.whl

agentmetry/__init__.py

@@ -0,0 +1,12 @@
+"""Agentmetry: a local-first flight recorder for AI coding agents.
+
+Everything lives under this one top-level package on purpose. The orchestrator
+used to ship `core`, `api` and `cli` as top-level names, which is harmless for an
+editable install inside this repo and antisocial once published: three of the
+most generic importable names in Python, dropped into someone else's
+site-packages, where they collide with whatever else claims them.
+"""
+
+from agentmetry.core.version import __version__
+
+__all__ = ["__version__"]

agentmetry/api/main.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+from fastapi import FastAPI, Query, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+
+from agentmetry.api.routes.audit import router as audit_router
+from agentmetry.api.websocket import ws_manager
+from agentmetry.api.ws_bridge import ws_event_bridge
+from agentmetry.core.auth import verify_ws_token
+from agentmetry.core.bus.audit_exporter import audit_exporter
+from agentmetry.core.bus.bridges import outbox_persister
+from agentmetry.core.bus.bus import bus
+from agentmetry.core.bus.outbox import get_outbox
+from agentmetry.core.config import settings
+from agentmetry.core.extensions import load_extensions
+from agentmetry.core.health import get_system_health
+from agentmetry.core.version import __version__
+
+logger = logging.getLogger(__name__)
+
+_LOG_DIR = Path(__file__).resolve().parents[2] / "data" / "logs"
+
+
+def _setup_logging() -> None:
+    """Persist app logs to disk so they survive a closed terminal."""
+    root = logging.getLogger()
+    if any(isinstance(h, RotatingFileHandler) for h in root.handlers):
+        return
+    _LOG_DIR.mkdir(parents=True, exist_ok=True)
+    formatter = logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s")
+
+    file_handler = RotatingFileHandler(
+        _LOG_DIR / "orchestrator.log",
+        maxBytes=5_000_000,
+        backupCount=3,
+        encoding="utf-8",
+    )
+    file_handler.setFormatter(formatter)
+    root.addHandler(file_handler)
+
+    console = logging.StreamHandler()
+    console.setFormatter(formatter)
+    root.addHandler(console)
+
+    if root.level in (logging.NOTSET, logging.WARNING):
+        root.setLevel(logging.INFO)
+
+
+_setup_logging()
+
+
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    from agentmetry.core.audit.migrate import backfill_db_from_jsonl
+
+    # Backfill SQLite from the existing JSONL trail. A broken or locked audit DB
+    # must degrade the dashboard, never stop the daemon from booting: the
+    # recorder's job is to keep recording.
+    try:
+        await asyncio.to_thread(backfill_db_from_jsonl)
+    except Exception:
+        logger.exception("Audit trail backfill failed; continuing without it")
+
+    # Replay events the hooks captured while this process was down. Same
+    # non-fatal contract as the backfill: a broken spool must not stop the
+    # recorder from booting.
+    #
+    # Deliberately not awaited. Draining a few thousand spooled events takes
+    # minutes, and awaiting it here holds the ingest port closed for the whole
+    # time — so every hook that fires during the drain is refused and spooled,
+    # which makes the next drain larger. The recorder has to be reachable first
+    # and catch up second.
+    from agentmetry.core.audit.spool import drain_forever, drain_spool
+
+    async def _boot_drain() -> None:
+        try:
+            await drain_spool()
+        except Exception:
+            logger.exception("Hook spool drain failed; continuing without it")
+
+    # Bring the triage index back in step with the trail. `reconcile_at_boot`
+    # declines rather than rebuilding when the trail cannot account for a
+    # decision the index already holds — a pruned or repointed trail must not
+    # silently erase the corrective-action record.
+    from agentmetry.core.audit.detection.disposition import reconcile_at_boot
+
+    try:
+        await asyncio.to_thread(reconcile_at_boot)
+    except Exception:
+        logger.exception("Disposition reconcile failed; continuing without it")
+
+    # Event bus first: everything downstream publishes onto it.
+    bus.set_initial_seq(get_outbox().max_seq())
+    bridge_tasks = [
+        asyncio.create_task(ws_event_bridge(), name="ws-bridge"),
+        asyncio.create_task(outbox_persister(), name="outbox-persister"),
+        asyncio.create_task(audit_exporter(), name="audit-exporter"),
+        asyncio.create_task(_boot_drain(), name="spool-boot-drain"),
+        # Keep draining for as long as we run. A boot-only drain leaves a
+        # backlog growing unnoticed whenever ingest is unreachable while the
+        # process itself stays up.
+        asyncio.create_task(drain_forever(), name="spool-drain"),
+    ]
+
+    # Drivers mount in the background: a slow npx download must not delay boot.
+    from agentmetry.core.drivers.host import get_mcp_host
+
+    mount_task = asyncio.create_task(get_mcp_host().mount_all(), name="driver-mounts")
+
+    from agentmetry.core.audit.hook_bootstrap import bootstrap_tier_b_hooks
+
+    try:
+        hook_paths = bootstrap_tier_b_hooks()
+        if hook_paths.get("cursor"):
+            logger.info("Global Cursor hooks ready: %s", hook_paths["cursor"])
+        if hook_paths.get("claude"):
+            logger.info("Global Claude hooks ready: %s", hook_paths["claude"])
+    except Exception as exc:
+        logger.warning("Tier B hook bootstrap failed: %s", exc)
+
+    # Launch transcript watcher for Antigravity in the background
+    import subprocess
+    import sys
+    watcher_process = None
+    try:
+        watcher_path = Path(__file__).resolve().parents[4] / "scripts" / "antigravity_transcript_watcher.py"
+        if watcher_path.exists():
+            watcher_process = subprocess.Popen(
+                [sys.executable, str(watcher_path)],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+            logger.info("Started Antigravity transcript watcher (PID: %s)", watcher_process.pid)
+    except Exception as exc:
+        logger.warning("Failed to start Antigravity transcript watcher: %s", exc)
+
+    yield
+    mount_task.cancel()
+    await get_mcp_host().unmount_all()
+    for task in bridge_tasks:
+        task.cancel()
+    if watcher_process:
+        watcher_process.terminate()
+
+
+app = FastAPI(
+    title="Agentmetry",
+    description="Open-source SIEM flight recorder for AI agent tool-use",
+    version=__version__,
+    lifespan=lifespan,
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:3000",
+        "http://127.0.0.1:3000",
+        "http://localhost:3001",
+        "http://127.0.0.1:3001",
+        "http://dashboard:3000",
+    ],
+    allow_origin_regex=r"http://(localhost|127\.0\.0\.1):\d+",
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(audit_router, prefix="/api/v1")
+
+load_extensions(app, settings=settings)
+
+
+@app.get("/api/v1/health")
+async def health():
+    return await get_system_health()
+
+
+
+
+
+@app.websocket("/ws/{session_id}")
+async def websocket_endpoint(
+    websocket: WebSocket,
+    session_id: str,
+    token: str | None = Query(None),
+):
+    if not verify_ws_token(token, websocket):
+        await websocket.close(code=4401)
+        return
+    await ws_manager.connect(websocket, session_id)
+    try:
+        while True:
+            await websocket.receive_text()
+    except WebSocketDisconnect:
+        ws_manager.disconnect(websocket, session_id)
+
+
+_DASHBOARD_DIR = Path(__file__).resolve().parents[3] / "dashboard" / "out"
+
+
+def mount_dashboard(target: FastAPI, directory: Path = _DASHBOARD_DIR) -> bool:
+    """Serve the dashboard's static export when it has been built.
+
+    Single-process mode: `npm run build` in apps/dashboard emits `out/`, which
+    the orchestrator serves at the root. Mounted last so it only catches paths
+    not already claimed by the API or WebSocket. Dev uses the :3000 dev server
+    instead, so this is a no-op when the export is absent.
+    """
+    if not directory.is_dir():
+        logger.info(
+            "Dashboard export not found at %s — run 'npm run build' in "
+            "apps/dashboard for single-process serving",
+            directory,
+        )
+        return False
+
+    from fastapi.staticfiles import StaticFiles
+
+    target.mount("/", StaticFiles(directory=str(directory), html=True), name="dashboard")
+    logger.info("Serving dashboard from %s", directory)
+    return True
+
+
+mount_dashboard(app)

agentmetry/api/routes/audit.py

@@ -0,0 +1,396 @@
+"""Agentmetry API — JSONL tail + external Tier B ingest."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Literal
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi.responses import FileResponse
+from pydantic import BaseModel, Field
+
+from agentmetry.core.auth import require_api_key
+from agentmetry.core.audit.detection.disposition import STATUSES, get_disposition_store
+from agentmetry.core.audit.ingest import ingest_external_event
+from agentmetry.core.config import settings
+
+router = APIRouter(prefix="/audit", tags=["audit"])
+
+_RUN_ACTION_TYPES = frozenset({
+    "session_start",
+    "session_end",
+    "tool_called",
+    "approval_request",
+    "approval_response",
+    "detection",  # correlated findings — must not be filtered out of the feed
+    "detection_disposition",  # and the human's answer to them
+})
+
+
+class IngestToolBody(BaseModel):
+    qualified: str = ""
+    server: str = ""
+    arguments: dict[str, Any] | None = None
+    input_hash: str = ""
+    command: str = ""
+    # Hook-side detection features, computed from the plaintext command before
+    # it was hashed away: category labels (`traits`) and the ATT&CK mapping.
+    # Without these fields pydantic silently drops them and default-config
+    # (hashed-only) events are invisible to every command-based sequence rule.
+    traits: list[str] = Field(default_factory=list)
+    mitre: dict[str, str] | None = None
+
+
+class ExternalIngestBody(BaseModel):
+    """Adapter payload — normalized to canonical v1.1 on ingest."""
+
+    source_app: str = Field(
+        ...,
+        description="cursor | claude | antigravity | codex | mcp_proxy | qwen | kimi | qoder | codebuddy | trae | crewai | opensre",
+    )
+    event_type: str = Field(
+        ...,
+        description="session_start | session_end | tool_called | tool_denied | tool_failed | approval_request | approval_response",
+    )
+    correlation_id: str = ""
+    session_id: str = ""
+    outcome: str = ""
+    reason: str = ""
+    skill_id: str = ""
+    tool_qualified: str = ""
+    tool: IngestToolBody | None = None
+    input_hash: str = ""
+    model_id: str = ""
+    adapter: str = ""
+    triggered_by: str = "manual"
+    timestamp_utc: str = ""
+    gated_action: dict[str, str] | None = None
+    # DLP verdict from the hook process. It scans plaintext before hashing, so
+    # this is the only place the finding can be captured — without this field
+    # pydantic drops it and a `log`-mode match is silently lost.
+    dlp: dict[str, Any] | None = None
+    tool_policy: dict[str, Any] | None = None
+
+
+def _parse_event_ts(event: dict[str, Any]) -> datetime | None:
+    ts = event.get("timestamp_utc")
+    if not isinstance(ts, str):
+        return None
+    try:
+        dt = datetime.fromisoformat(ts.replace("Z", "+00:00"))
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        return dt
+    except ValueError:
+        return None
+
+
+def _parse_query_ts(value: str) -> datetime:
+    try:
+        dt = datetime.fromisoformat(value.replace("Z", "+00:00"))
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        return dt
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=f"Invalid timestamp: {value}") from exc
+
+
+# Events written before the Agentmetry rename carry the legacy first-party name.
+# Normalize on read so an existing trail keeps rendering instead of silently
+# vanishing behind the source filter.
+_LEGACY_SOURCE_APPS = frozenset({"blackbox"})
+
+
+def _normalize_source_app(name: str) -> str:
+    return "agentmetry" if name in _LEGACY_SOURCE_APPS else name
+
+
+def _event_source_app(event: dict[str, Any]) -> str:
+    source = event.get("source")
+    if isinstance(source, dict) and source.get("app"):
+        return _normalize_source_app(str(source["app"]).lower())
+    agent = event.get("agent")
+    if isinstance(agent, dict) and agent.get("name"):
+        name = _normalize_source_app(str(agent["name"]).lower())
+        if name != "agentmetry":
+            return name
+    return "agentmetry"
+
+
+@router.post("/ingest", dependencies=[Depends(require_api_key)])
+async def audit_ingest(body: ExternalIngestBody):
+    """Accept canonical adapter events from Cursor, Claude, MCP proxy, etc."""
+    if not settings.audit_ingest_enabled:
+        raise HTTPException(status_code=503, detail="External audit ingest is disabled")
+    if not settings.audit_export_enabled:
+        raise HTTPException(status_code=503, detail="Audit export is disabled")
+
+    payload = body.model_dump(exclude_none=True)
+    try:
+        canonical = await ingest_external_event(payload)
+    except ValueError as exc:
+        raise HTTPException(status_code=503, detail=str(exc)) from exc
+    except RuntimeError as exc:
+        raise HTTPException(status_code=503, detail=str(exc)) from exc
+
+    return {
+        "status": "accepted",
+        "event_id": canonical.get("event_id"),
+        "correlation_id": canonical.get("correlation_id"),
+        "action": canonical.get("action"),
+        "source": canonical.get("source"),
+    }
+
+
+@router.get("/tail", dependencies=[Depends(require_api_key)])
+async def audit_tail(
+    limit: int = Query(50, ge=1, le=500),
+    scope: Literal["runs", "all"] = Query(
+        "runs",
+        description="runs = session/tool/approval only; all = include driver config_change",
+    ),
+    session_id: str | None = Query(
+        None,
+        description="When set, Agentmetry events filter to session; external apps always shown",
+    ),
+    sources: str | None = Query(
+        None,
+        description="Comma-separated source apps: agentmetry,cursor,claude,antigravity,mcp_proxy",
+    ),
+    since_minutes: int | None = Query(
+        None,
+        ge=1,
+        le=10080,
+        description="Only events within the last N minutes",
+    ),
+    before_utc: str | None = Query(
+        None,
+        description="Return events strictly before this ISO timestamp (page older)",
+    ),
+    after_utc: str | None = Query(
+        None,
+        description="Return events strictly after this ISO timestamp (page newer)",
+    ),
+    focus: Literal["denied", "dlp", "policy", "detection"] | None = Query(
+        None,
+        description=(
+            "Server-side slice matching Analytics dogfood counts: "
+            "denied | dlp | policy | detection"
+        ),
+    ),
+):
+    """Return canonical audit events from the local JSONL forwarder."""
+    from agentmetry.core.audit.trail_db import get_trail_db
+    path = Path(settings.audit_export_path)
+    if not settings.audit_export_enabled:
+        return {"events": [], "path": str(path), "enabled": False, "pagination": {"has_older": False, "has_newer": False, "count": 0}}
+
+    source_set: set[str] | None = None
+    if sources:
+        source_set = {s.strip().lower() for s in sources.split(",") if s.strip()}
+
+    try:
+        events, pagination = get_trail_db().tail(
+            limit=limit,
+            scope=scope,
+            sources=source_set,
+            session_id=session_id,
+            since_minutes=since_minutes,
+            before_utc=before_utc,
+            after_utc=after_utc,
+            focus=focus,
+        )
+    except HTTPException:
+        raise
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=str(exc)) from exc
+    return {"events": events, "path": str(path), "enabled": True, "pagination": pagination}
+
+
+@router.get("/session/{correlation_id}", dependencies=[Depends(require_api_key)])
+async def audit_session(
+    correlation_id: str,
+    limit: int = Query(2000, ge=1, le=10000),
+):
+    """Return every event for one correlation_id across the whole trail.
+
+    The dashboard's in-panel search only sees the loaded window, so viewing a
+    full session — especially an older one — needs a server-side lookup that
+    scans the entire JSONL rather than the last N lines.
+    """
+    from agentmetry.core.audit.trail_db import get_trail_db
+    if not settings.audit_export_enabled:
+        return {"events": [], "correlation_id": correlation_id, "enabled": False, "count": 0}
+    try:
+        events = get_trail_db().session(correlation_id, limit=limit)
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=str(exc)) from exc
+    return {
+        "events": events,
+        "correlation_id": correlation_id,
+        "enabled": True,
+        "count": len(events),
+    }
+
+
+@router.get("/detections/{correlation_id}", dependencies=[Depends(require_api_key)])
+async def audit_detections(correlation_id: str):
+    """Run correlated behavioral rules over one session and return detections.
+
+    A detection is a named, ordered pattern of events (e.g. credential access
+    then network egress) — the signal per-event MITRE tags can't express on
+    their own. Scans the whole trail for the session, then correlates.
+    """
+    from agentmetry.core.audit.detection import run_detections
+    from agentmetry.core.audit.trail_db import get_trail_db
+
+    if not settings.audit_export_enabled:
+        return {"detections": [], "correlation_id": correlation_id, "enabled": False, "count": 0}
+    try:
+        events = get_trail_db().events_for_detection(correlation_id)
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=str(exc)) from exc
+    detections = run_detections(events)
+    dispositions = get_disposition_store().for_correlation(correlation_id)
+    for detection in detections:
+        detection.disposition = dispositions.get(detection.rule_id)
+    return {
+        "detections": [d.as_dict() for d in detections],
+        "correlation_id": correlation_id,
+        "enabled": True,
+        "count": len(detections),
+        "untriaged": sum(1 for d in detections if d.disposition is None),
+    }
+
+
+class DispositionBody(BaseModel):
+    """A triage decision. `note` is operator prose, never captured content."""
+
+    correlation_id: str = ""
+    rule_id: str
+    status: str
+    assignee: str = ""
+    note: str = ""
+    decided_by: str = ""
+    severity: str = ""
+
+
+@router.post("/detections/disposition", dependencies=[Depends(require_api_key)])
+async def audit_set_disposition(body: DispositionBody):
+    """Record what a human decided about a detection.
+
+    The decision is appended to the trail as a `detection_disposition` event
+    before the index is updated, so it lands on the same hash chain as the
+    finding it answers. Superseding a disposition keeps the previous one in
+    `history`: "false positive" later becoming "confirmed" is precisely the
+    transition an auditor needs to see.
+    """
+    from agentmetry.core.audit.detection.disposition import DispositionError, apply_disposition
+
+    try:
+        current = await apply_disposition(
+            correlation_id=body.correlation_id,
+            rule_id=body.rule_id,
+            status=body.status,
+            assignee=body.assignee,
+            note=body.note,
+            decided_by=body.decided_by,
+            severity=body.severity,
+        )
+    except DispositionError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=str(exc)) from exc
+    return {"disposition": current}
+
+
+@router.get("/detections/dispositions/all", dependencies=[Depends(require_api_key)])
+async def audit_list_dispositions():
+    """Every triage decision in force, plus the status breakdown."""
+    store = get_disposition_store()
+    return {
+        "dispositions": store.all(),
+        "counts": store.counts(),
+        "statuses": list(STATUSES),
+    }
+
+
+@router.get("/dogfood", dependencies=[Depends(require_api_key)])
+async def audit_dogfood():
+    """Progress against the four-week beta gate.
+
+    Exposed so the dashboard can show it. A gate you have to remember to run a
+    command for is one you stop running, which is how this one went weeks
+    without being started in the first place.
+    """
+    from agentmetry.core.audit.dogfood import assess
+
+    try:
+        return assess().as_dict()
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+
+@router.get("/export/evidence", dependencies=[Depends(require_api_key)])
+async def audit_export_evidence():
+    """Generate and download a tamper-evident evidence pack (SHA-256 integrity manifest)."""
+    from agentmetry.core.audit.evidence_pack import build_evidence_pack, default_export_path, write_evidence_pack
+    from datetime import datetime, timezone
+
+    # Dates, not datetimes: `default_export_path` embeds them in the filename,
+    # and a datetime's isoformat carries colons, which Windows rejects.
+    to_date = datetime.now(timezone.utc).date()
+    from_date = to_date - timedelta(days=30)  # Export last 30 days
+
+    pack = build_evidence_pack(from_date, to_date)
+    out_path = default_export_path(from_date, to_date)
+    write_evidence_pack(pack, out_path)
+
+    return FileResponse(
+        path=out_path,
+        media_type="application/json",
+        filename=out_path.name,
+    )
+
+
+@router.get("/status", dependencies=[Depends(require_api_key)])
+async def audit_status():
+    """Freshness + per-source counts so the dashboard can show 'last event N min ago'.
+
+    Powers the freshness badge and `selftest` — makes silent hook failure visible
+    instead of the operator falsely believing they are being audited.
+    """
+    from agentmetry.core.audit.spool import spool_depth, spool_oldest_age_seconds
+    from agentmetry.core.audit.trail_db import get_trail_db
+    path = Path(settings.audit_export_path)
+    if not settings.audit_export_enabled:
+        return {"enabled": False, "last_event_utc": None, "recent": 0, "by_source": {}, "path": str(path)}
+
+    status_data = get_trail_db().status()
+    # Pending spool depth belongs in the same payload as freshness. A feed that
+    # looks quiet because nothing happened and a feed that looks quiet because
+    # capture is backing up are indistinguishable without it, and that
+    # ambiguity is how a multi-day gap goes unnoticed.
+    return {
+        "enabled": True,
+        "last_event_utc": status_data["last_event_utc"],
+        "recent": status_data["recent"],
+        "by_source": status_data["by_source"],
+        "path": str(path),
+        "spool_pending": spool_depth(),
+        "spool_oldest_age_seconds": spool_oldest_age_seconds(),
+    }
+
+
+@router.get("/stats", dependencies=[Depends(require_api_key)])
+async def audit_stats(days: int = Query(7, ge=1, le=90)):
+    """Weekly dogfood metrics — same data as `agentmetry stats --days N`."""
+    from agentmetry.core.audit.trail_db import get_trail_db
+
+    if not settings.audit_export_enabled:
+        return {"enabled": False, "window_days": days}
+
+    return {"enabled": True, **get_trail_db().stats(window_days=days)}

agentmetry/api/websocket.py

@@ -0,0 +1,53 @@
+"""WebSocket connection manager for real-time telemetry streaming."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from fastapi import WebSocket
+
+
+# Session id that mirrors every event; the dashboard subscribes to it to
+# observe autonomous runs that happen in other sessions.
+GLOBAL_SESSION = "global"
+
+
+class ConnectionManager:
+    def __init__(self):
+        self.active: dict[str, list[WebSocket]] = {}
+
+    async def connect(self, websocket: WebSocket, session_id: str) -> None:
+        await websocket.accept()
+        if session_id not in self.active:
+            self.active[session_id] = []
+        self.active[session_id].append(websocket)
+
+    def disconnect(self, websocket: WebSocket, session_id: str) -> None:
+        if session_id in self.active:
+            self.active[session_id] = [
+                ws for ws in self.active[session_id] if ws != websocket
+            ]
+            if not self.active[session_id]:
+                del self.active[session_id]
+
+    async def broadcast(self, session_id: str, event: dict[str, Any]) -> None:
+        await self._send(session_id, event)
+        if session_id != GLOBAL_SESSION:
+            await self._send(GLOBAL_SESSION, {**event, "origin_session": session_id})
+
+    async def _send(self, session_id: str, event: dict[str, Any]) -> None:
+        if session_id not in self.active:
+            return
+        payload = json.dumps(event)
+        dead: list[WebSocket] = []
+        for ws in self.active[session_id]:
+            try:
+                await ws.send_text(payload)
+            except Exception:
+                dead.append(ws)
+        for ws in dead:
+            self.disconnect(ws, session_id)
+
+
+ws_manager = ConnectionManager()