htmlgraph 0.27.7__py3-none-any.whl → 0.28.1__py3-none-any.whl

htmlgraph/api/broadcast_websocket.py

@@ -0,0 +1,115 @@
+"""
+Broadcast WebSocket Endpoint - Real-time Cross-Session Updates
+
+WebSocket endpoint for receiving broadcast events from other sessions.
+Clients subscribe to get notified when features/tracks/spikes are updated.
+"""
+
+import logging
+import uuid
+from typing import Any
+
+from fastapi import WebSocket, WebSocketDisconnect
+
+from htmlgraph.api.broadcast import BroadcastEventType
+from htmlgraph.api.websocket import EventSubscriptionFilter, WebSocketManager
+
+logger = logging.getLogger(__name__)
+
+
+async def websocket_broadcasts_endpoint(
+    websocket: WebSocket,
+    websocket_manager: WebSocketManager,
+    get_db: Any,
+) -> None:
+    """
+    WebSocket endpoint for cross-session broadcast events.
+
+    Clients connect and receive real-time notifications when:
+    - Features are created/updated/deleted
+    - Tracks are updated
+    - Spikes are updated
+    - Status changes occur
+    - Links are added
+
+    Example client code:
+    ```javascript
+    const ws = new WebSocket('ws://localhost:8000/ws/broadcasts');
+    ws.onmessage = (event) => {
+        const msg = JSON.parse(event.data);
+        if (msg.type === 'broadcast_event') {
+            handleBroadcastEvent(msg);
+        }
+    };
+    ```
+
+    Args:
+        websocket: FastAPI WebSocket connection
+        websocket_manager: WebSocketManager for event distribution
+        get_db: Database connection factory
+    """
+    client_id = str(uuid.uuid4())
+
+    # Create subscription filter for broadcast events
+    subscription_filter = EventSubscriptionFilter(
+        event_types=[
+            "broadcast_event",
+            BroadcastEventType.FEATURE_UPDATED.value,
+            BroadcastEventType.FEATURE_CREATED.value,
+            BroadcastEventType.FEATURE_DELETED.value,
+            BroadcastEventType.TRACK_UPDATED.value,
+            BroadcastEventType.SPIKE_UPDATED.value,
+            BroadcastEventType.STATUS_CHANGED.value,
+            BroadcastEventType.LINK_ADDED.value,
+            BroadcastEventType.COMMENT_ADDED.value,
+        ]
+    )
+
+    # Connect to global broadcast channel
+    # Note: Using "broadcasts" as a pseudo-session ID for global channel
+    connected = await websocket_manager.connect(
+        websocket=websocket,
+        session_id="broadcasts",
+        client_id=client_id,
+        subscription_filter=subscription_filter,
+    )
+
+    if not connected:
+        logger.warning(f"Failed to connect broadcast client {client_id}")
+        return
+
+    logger.info(f"Broadcast client connected: {client_id}")
+
+    try:
+        # Keep connection alive and handle incoming messages
+        while True:
+            try:
+                # Receive messages from client (for heartbeat/ping)
+                data = await websocket.receive_text()
+
+                # Handle client messages
+                if data == "ping":
+                    await websocket.send_json({"type": "pong"})
+                elif data == "subscribe":
+                    # Client can request initial state sync here
+                    await websocket.send_json(
+                        {
+                            "type": "subscribed",
+                            "client_id": client_id,
+                            "message": "Connected to broadcast channel",
+                        }
+                    )
+                else:
+                    logger.debug(f"Received message from client {client_id}: {data}")
+
+            except WebSocketDisconnect:
+                logger.info(f"Broadcast client disconnected: {client_id}")
+                break
+            except Exception as e:
+                logger.error(f"Error handling client message: {e}")
+                break
+
+    finally:
+        # Cleanup on disconnect
+        await websocket_manager.disconnect("broadcasts", client_id)
+        logger.info(f"Broadcast client cleanup completed: {client_id}")

htmlgraph/api/cost_alerts_websocket.py

@@ -132,14 +132,11 @@ class CostAlertStreamManager:
             client_id: Client ID
             cost_alert_filter: Subscription filter for alerts
         """
-        if (
-            session_id not in self.websocket_manager.connections
-            or client_id not in self.websocket_manager.connections[session_id]
-        ):
-            logger.warning(f"Client not found: {session_id}/{client_id}")
+        if client_id not in self.websocket_manager.connections:
+            logger.warning(f"Client not found: {client_id}")
             return
 
-        client = self.websocket_manager.connections[session_id][client_id]
+        client = self.websocket_manager.connections[client_id]
         last_alert_time = self.last_alert_timestamp.get(
             session_id, "1970-01-01T00:00:00Z"
         )
@@ -280,13 +277,10 @@ class CostAlertStreamManager:
             client_id: Client ID
             update_interval_seconds: How often to send updates
         """
-        if (
-            session_id not in self.websocket_manager.connections
-            or client_id not in self.websocket_manager.connections[session_id]
-        ):
+        if client_id not in self.websocket_manager.connections:
             return
 
-        client = self.websocket_manager.connections[session_id][client_id]
+        client = self.websocket_manager.connections[client_id]
 
         try:
             while True:
@@ -337,13 +331,10 @@ class CostAlertStreamManager:
             update_interval_seconds: How often to update predictions
             lookback_minutes: How far back to analyze
         """
-        if (
-            session_id not in self.websocket_manager.connections
-            or client_id not in self.websocket_manager.connections[session_id]
-        ):
+        if client_id not in self.websocket_manager.connections:
             return
 
-        client = self.websocket_manager.connections[session_id][client_id]
+        client = self.websocket_manager.connections[client_id]
 
         try:
             while True:

htmlgraph/api/main.py

@@ -25,7 +25,7 @@ from pathlib import Path
 from typing import Any
 
 import aiosqlite
-from fastapi import FastAPI, Request, WebSocket, WebSocketDisconnect
+from fastapi import FastAPI, HTTPException, Request, WebSocket, WebSocketDisconnect
 from fastapi.responses import HTMLResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
@@ -380,6 +380,31 @@ def get_app(db_path: str) -> FastAPI:
         finally:
             await db.close()
 
+    # ========== PRESENCE WIDGET DEMO (Phase 6) ==========
+
+    @app.get("/views/presence-widget", response_class=HTMLResponse)
+    async def presence_widget_demo(request: Request) -> HTMLResponse:
+        """Phase 6 Demo: Real-time Presence Widget showing active agents across sessions.
+
+        This widget demonstrates:
+        - WebSocket connections to broadcast stream
+        - Real-time presence updates (<100ms latency)
+        - Multi-session agent coordination
+        - Integration with Phase 5 broadcast API
+
+        Try it out:
+        1. Open this page in your browser
+        2. In another terminal, emit presence events
+        3. Watch the dashboard update in real-time!
+        """
+        widget_path = Path(__file__).parent / "static" / "presence-widget-demo.html"
+        if widget_path.exists():
+            return HTMLResponse(content=widget_path.read_text())
+        else:
+            raise HTTPException(
+                status_code=404, detail="Presence widget demo not found"
+            )
+
     # ========== ACTIVITY FEED ENDPOINTS ==========
 
     @app.get("/views/activity-feed", response_class=HTMLResponse)
@@ -2480,6 +2505,115 @@ def get_app(db_path: str) -> FastAPI:
             logger.error(f"WebSocket error: {e}")
             await websocket.close(code=1011)
 
+    # ========================================================================
+    # PRESENCE TRACKING API - Phase 1: Cross-Agent Presence
+    # ========================================================================
+
+    @app.get("/api/presence")
+    async def get_all_presence() -> dict[str, Any]:
+        """
+        Get current presence state for all agents.
+
+        Returns:
+            Dictionary with agents list and timestamp
+        """
+        try:
+            from htmlgraph.api.presence import PresenceManager
+
+            presence_mgr = PresenceManager(db_path=db_path)
+            agents = presence_mgr.get_all_presence()
+
+            return {
+                "agents": [agent.to_dict() for agent in agents],
+                "timestamp": datetime.now().isoformat(),
+            }
+        except Exception as e:
+            logger.error(f"Error getting presence: {e}")
+            return {"agents": [], "timestamp": datetime.now().isoformat()}
+
+    @app.get("/api/presence/{agent_id}")
+    async def get_agent_presence(agent_id: str) -> dict[str, Any]:
+        """
+        Get presence for specific agent.
+
+        Args:
+            agent_id: Agent identifier
+
+        Returns:
+            Agent presence dictionary
+        """
+        try:
+            from htmlgraph.api.presence import PresenceManager
+
+            presence_mgr = PresenceManager(db_path=db_path)
+            presence = presence_mgr.get_agent_presence(agent_id)
+
+            if not presence:
+                raise HTTPException(status_code=404, detail="Agent not found")
+
+            return presence.to_dict()
+        except HTTPException:
+            raise
+        except Exception as e:
+            logger.error(f"Error getting agent presence: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+    @app.websocket("/ws/presence")
+    async def websocket_presence(websocket: WebSocket) -> None:
+        """
+        WebSocket endpoint for real-time agent presence updates.
+
+        Clients subscribe to receive:
+        - Initial presence state for all agents
+        - Updates when agents become active/idle/offline
+        """
+        client_id = f"presence-{int(time.time() * 1000)}"
+
+        try:
+            await websocket.accept()
+            logger.info(f"Presence WebSocket client connected: {client_id}")
+
+            # Send initial presence state
+            from htmlgraph.api.presence import PresenceManager
+
+            presence_mgr = PresenceManager(db_path=db_path)
+            initial_presence = presence_mgr.get_all_presence()
+
+            await websocket.send_json(
+                {
+                    "type": "presence_state",
+                    "agents": [p.to_dict() for p in initial_presence],
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+
+            # Poll for presence updates
+            poll_interval = 1.0  # Check every second
+
+            while True:
+                await asyncio.sleep(poll_interval)
+
+                # Get current presence
+                current_presence = presence_mgr.get_all_presence()
+
+                # Send update (client will diff against previous state)
+                await websocket.send_json(
+                    {
+                        "type": "presence_update",
+                        "agents": [p.to_dict() for p in current_presence],
+                        "timestamp": datetime.now().isoformat(),
+                    }
+                )
+
+        except WebSocketDisconnect:
+            logger.info(f"Presence WebSocket client disconnected: {client_id}")
+        except Exception as e:
+            logger.error(f"Presence WebSocket error: {e}")
+            try:
+                await websocket.close(code=1011)
+            except Exception:
+                pass
+
     return app