Pin each SDR service to a dongle by serial; OP25 always opens its SDR by serial

Fixes node-26#11. OP25's generated config said "rtl" (= whichever dongle
enumerates first), so on 2-SDR nodes a decoder could take OP25's dongle
and stop recording. Now:

- sdr_pins: {op25|adsb|ais: serial}, absent = automatic. Every OP25
  config generation (op25_client.generate_config) rewrites the device to
  rtl=<serial>: the pin, else the first dongle's serial, which is what
  "rtl" always opened. Left as "rtl" only for unknown/shared serials.
- secondary-sdr: /secondary/devices lists dongles + serials via librtlsdr
  (works while claimed). apply(priority, pins, reserved) never touches
  OP25's dongle, gives a pinned service only its own dongle, lets a
  higher-priority service take a spare from a lower one, and still runs a
  pinned lower-priority service when the top pick has no dongle.
- sdr_settings.py replaces secondary_priority.py: one apply path for the
  local dashboard, the new set_sdr_config C2 command (set_secondary_priority
  kept as an alias) and config pushes. OP25 restarts only when its own
  dongle changes. Checkin reports sdr_devices, sdr_pins, op25_sdr_serial.
- Local dashboard: 'SDRs' card with an OP25 SDR dropdown and a per-service
  dongle dropdown, duplicate-serial and double-pin warnings.

Verified: edge-node pytest 194 passed; secondary-sdr tests 7 passed;
flake8 clean; page JS passes node --check.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

drb-edge-node/app/routers/api.py

@@ -1,5 +1,6 @@
 from fastapi import APIRouter, Depends, HTTPException, Body
-from typing import List, Optional
+from pydantic import BaseModel
+from typing import Dict, List, Optional
 import asyncio
 import httpx
 from app.config import settings
@@ -204,28 +205,42 @@ async def ack_override(timeout_minutes: int = Body(1440)):
         raise HTTPException(500, f"Failed to contact C2: {e}")
 
 
-@router.get("/secondary")
-async def get_secondary():
-    """Secondary SDR priority plus what's actually running (node-26#9)."""
+@router.get("/sdr")
+async def get_sdr():
+    """Which SDR does what: detected dongles, pins, priority, what's running."""
     from app.internal.secondary_sdr_client import secondary_sdr_client
+    from app.internal.sdr_settings import op25_serial
+    cfg = load_node_config()
+    devs = await secondary_sdr_client.devices()
     status = await secondary_sdr_client.status()
     return {
-        "priority": load_node_config().secondary_sdr_priority,
+        "devices": devs,  # None = secondary-sdr service unreachable
+        "op25_serial": op25_serial(cfg, devs),
+        "pins": cfg.sdr_pins,
+        "priority": cfg.secondary_sdr_priority,
         "modes": list(SECONDARY_SDR_MODES),
         "running": [r["mode"] for r in status.get("running", [])] if status else None,
-        "sdr_count": status.get("sdr_count") if status else None,
     }
 
 
-@router.post("/secondary/priority")
-async def set_secondary_priority(priority: List[str] = Body(..., embed=True)):
-    """Set the ordered list the spare SDRs work through. Never restarts op25."""
-    from app.internal.secondary_priority import set_secondary_priority as apply_priority
-    unknown = [m for m in priority if m not in SECONDARY_SDR_MODES]
-    if unknown:
-        raise HTTPException(400, f"Unknown secondary SDR mode(s): {unknown}")
-    running = await apply_priority(priority)
-    return {"ok": True, "priority": load_node_config().secondary_sdr_priority, "running": running}
+class SdrSettingsBody(BaseModel):
+    priority: Optional[List[str]] = None
+    pins: Optional[Dict[str, Optional[str]]] = None  # service -> serial; null/"" = automatic
+
+
+@router.post("/sdr")
+async def set_sdr(body: SdrSettingsBody):
+    """Set priority and/or pins. Restarts OP25 only if OP25's own SDR changes."""
+    from app.internal.sdr_settings import set_sdr_settings
+    if body.priority is not None:
+        unknown = [m for m in body.priority if m not in SECONDARY_SDR_MODES]
+        if unknown:
+            raise HTTPException(400, f"Unknown secondary SDR mode(s): {unknown}")
+    try:
+        running = await set_sdr_settings(body.priority, body.pins)
+    except ValueError as e:
+        raise HTTPException(400, str(e))
+    return {"ok": True, "running": running}
 
 
 @router.post("/discord/join")