Initial loopbacl

app/routers/health.py

@@ -17,6 +17,7 @@ class HealthResponse(BaseModel):
     database_size_mb: float
     oldest_undecrypted_timestamp: int | None
     mqtt_status: str | None = None
+    loopback_eligible: bool = False
 
 
 async def build_health_data(radio_connected: bool, connection_info: str | None) -> dict:
@@ -53,6 +54,7 @@ async def build_health_data(radio_connected: bool, connection_info: str | None)
         "database_size_mb": db_size_mb,
         "oldest_undecrypted_timestamp": oldest_ts,
         "mqtt_status": mqtt_status,
+        "loopback_eligible": settings.loopback_eligible,
     }
 
 

app/routers/loopback.py

@@ -0,0 +1,116 @@
+"""WebSocket endpoint for loopback transport (browser-bridged radio connection)."""
+
+import asyncio
+import json
+import logging
+
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+from starlette.websockets import WebSocketState
+
+from app.config import settings
+from app.loopback import LoopbackTransport
+from app.radio import radio_manager
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+@router.websocket("/ws/transport")
+async def loopback_transport(websocket: WebSocket) -> None:
+    """Bridge a browser-side serial/BLE connection to the backend MeshCore stack.
+
+    Protocol:
+      1. Client sends init JSON: {"type": "init", "mode": "serial"|"ble"}
+      2. Binary frames flow bidirectionally (raw bytes for BLE, framed for serial)
+      3. Either side can send {"type": "disconnect"} to tear down
+    """
+    # Guard: reject if an explicit transport is configured via env vars
+    if not settings.loopback_eligible:
+        await websocket.accept()
+        await websocket.close(code=4003, reason="Explicit transport configured")
+        return
+
+    # Guard: reject if the radio is already connected (direct or another loopback)
+    if radio_manager.is_connected:
+        await websocket.accept()
+        await websocket.close(code=4004, reason="Radio already connected")
+        return
+
+    await websocket.accept()
+
+    transport: LoopbackTransport | None = None
+    setup_task: asyncio.Task | None = None
+
+    try:
+        # Wait for init message
+        init_raw = await asyncio.wait_for(websocket.receive_text(), timeout=10.0)
+        init_msg = json.loads(init_raw)
+
+        if init_msg.get("type") != "init" or init_msg.get("mode") not in ("serial", "ble"):
+            await websocket.close(code=4001, reason="Invalid init message")
+            return
+
+        mode = init_msg["mode"]
+        logger.info("Loopback init: mode=%s", mode)
+
+        # Create transport and MeshCore instance
+        transport = LoopbackTransport(websocket, mode)
+
+        from meshcore import MeshCore
+
+        mc = MeshCore(transport, auto_reconnect=False, max_reconnect_attempts=0)
+        await mc.connect()
+
+        if not mc.is_connected:
+            logger.warning("Loopback MeshCore failed to connect")
+            await websocket.close(code=4005, reason="MeshCore handshake failed")
+            return
+
+        connection_info = f"Loopback ({mode})"
+        radio_manager.connect_loopback(mc, connection_info)
+
+        # Run post-connect setup in background so the receive loop can run
+        setup_task = asyncio.create_task(radio_manager.post_connect_setup())
+
+        # Main receive loop
+        while True:
+            message = await websocket.receive()
+
+            if message.get("type") == "websocket.disconnect":
+                break
+
+            if "bytes" in message and message["bytes"]:
+                transport.handle_rx(message["bytes"])
+            elif "text" in message and message["text"]:
+                try:
+                    text_msg = json.loads(message["text"])
+                    if text_msg.get("type") == "disconnect":
+                        logger.info("Loopback client requested disconnect")
+                        break
+                except (json.JSONDecodeError, TypeError):
+                    pass
+
+    except WebSocketDisconnect:
+        logger.info("Loopback WebSocket disconnected")
+    except asyncio.TimeoutError:
+        logger.warning("Loopback init timeout")
+        if websocket.client_state == WebSocketState.CONNECTED:
+            await websocket.close(code=4002, reason="Init timeout")
+    except Exception as e:
+        logger.exception("Loopback error: %s", e)
+    finally:
+        if setup_task is not None:
+            setup_task.cancel()
+            try:
+                await setup_task
+            except (asyncio.CancelledError, Exception):
+                pass
+
+        await radio_manager.disconnect_loopback()
+
+        if websocket.client_state == WebSocketState.CONNECTED:
+            try:
+                await websocket.close()
+            except Exception:
+                pass