Initial commit — DRB client (edge node) stack

Includes edge-node (FastAPI/MQTT/Discord voice), op25-container (SDR decoder),
and icecast (audio streaming).

drb-edge-node/app/config.py

@@ -0,0 +1,39 @@
+from pydantic_settings import BaseSettings
+from typing import Optional
+
+
+class Settings(BaseSettings):
+    # Node identity
+    node_id: str
+    node_name: str = "Unnamed Node"
+    node_lat: float = 0.0
+    node_lon: float = 0.0
+
+    # MQTT
+    mqtt_broker: str
+    mqtt_port: int = 1883
+    mqtt_user: Optional[str] = None
+    mqtt_pass: Optional[str] = None
+
+    # C2 server (audio upload destination); None disables upload
+    c2_url: Optional[str] = None
+
+    # Local Icecast
+    icecast_host: str = "localhost"
+    icecast_port: int = 8000
+    icecast_mount: str = "/radio"
+    icecast_source_password: str = "hackme"
+
+    # OP25 container
+    op25_api_url: str = "http://localhost:8001"
+    op25_terminal_url: str = "http://localhost:8081"
+
+    # Paths (volume mounts)
+    config_path: str = "/configs"
+    recordings_path: str = "/recordings"
+
+    class Config:
+        env_file = ".env"
+
+
+settings = Settings()

drb-edge-node/app/internal/call_recorder.py

@@ -0,0 +1,117 @@
+import asyncio
+from pathlib import Path
+from datetime import datetime, timezone
+from typing import Optional
+import httpx
+from app.config import settings
+from app.internal import credentials
+from app.internal.logger import logger
+
+MAX_RECORDING_SECONDS = 600  # 10 min safety cap; FFmpeg terminates long-running calls
+
+
+class CallRecorder:
+    def __init__(self):
+        self._process: Optional[asyncio.subprocess.Process] = None
+        self._current_call_id: Optional[str] = None
+        self._current_file: Optional[Path] = None
+        self._icecast_url = (
+            f"http://{settings.icecast_host}:{settings.icecast_port}{settings.icecast_mount}"
+        )
+        self._recordings_dir = Path(settings.recordings_path)
+
+    async def start_recording(self, call_id: str) -> bool:
+        if self._process:
+            logger.warning("Recording already running — ignoring start.")
+            return False
+
+        self._recordings_dir.mkdir(parents=True, exist_ok=True)
+        ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+        self._current_file = self._recordings_dir / f"{ts}_{call_id}.mp3"
+        self._current_call_id = call_id
+
+        cmd = [
+            "ffmpeg", "-y",
+            "-i", self._icecast_url,
+            "-acodec", "copy",
+            "-t", str(MAX_RECORDING_SECONDS),
+            str(self._current_file),
+        ]
+
+        try:
+            self._process = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.DEVNULL,
+                stderr=asyncio.subprocess.DEVNULL,
+            )
+            logger.info(f"Recording started: {self._current_file.name}")
+            return True
+        except Exception as e:
+            logger.error(f"FFmpeg start failed: {e}")
+            self._process = None
+            self._current_file = None
+            self._current_call_id = None
+            return False
+
+    async def stop_recording(self) -> Optional[Path]:
+        if not self._process:
+            return None
+
+        proc = self._process
+        output_file = self._current_file
+        self._process = None
+        self._current_file = None
+        self._current_call_id = None
+
+        try:
+            proc.terminate()
+            await asyncio.wait_for(proc.wait(), timeout=5)
+        except asyncio.TimeoutError:
+            proc.kill()
+        except ProcessLookupError:
+            pass
+
+        if output_file and output_file.exists() and output_file.stat().st_size > 0:
+            logger.info(f"Recording saved: {output_file.name} ({output_file.stat().st_size} bytes)")
+            return output_file
+
+        logger.warning("Recording file empty or missing — discarding.")
+        return None
+
+    async def upload_recording(self, file_path: Path, call_id: str) -> Optional[str]:
+        if not settings.c2_url:
+            logger.info("No C2_URL configured — skipping upload.")
+            return None
+
+        upload_url = f"{settings.c2_url}/upload"
+        api_key = credentials.get_api_key()
+        headers = {"Authorization": f"Bearer {api_key}"} if api_key else {}
+
+        try:
+            async with httpx.AsyncClient(timeout=120) as client:
+                with open(file_path, "rb") as f:
+                    r = await client.post(
+                        upload_url,
+                        files={"file": (file_path.name, f, "audio/mpeg")},
+                        data={"call_id": call_id, "node_id": settings.node_id},
+                        headers=headers,
+                    )
+                    r.raise_for_status()
+                    audio_url = r.json().get("url")
+                    logger.info(f"Upload complete: {audio_url}")
+                    return audio_url
+        except Exception as e:
+            logger.error(f"Upload failed: {e}")
+            return None
+        finally:
+            try:
+                file_path.unlink()
+            except Exception:
+                pass
+
+    @property
+    def is_recording(self) -> bool:
+        return self._process is not None
+
+
+call_recorder = CallRecorder()

drb-edge-node/app/internal/config_manager.py

@@ -0,0 +1,43 @@
+import json
+from pathlib import Path
+from typing import Optional
+from app.config import settings
+from app.models import NodeConfig, SystemConfig
+from app.internal.logger import logger
+
+_CONFIG_FILE = Path(settings.config_path) / "node_config.json"
+
+
+def load_node_config() -> NodeConfig:
+    if _CONFIG_FILE.exists():
+        try:
+            data = json.loads(_CONFIG_FILE.read_text())
+            return NodeConfig(**data)
+        except Exception as e:
+            logger.warning(f"Could not load node config, using defaults: {e}")
+
+    return NodeConfig(
+        node_id=settings.node_id,
+        node_name=settings.node_name,
+        lat=settings.node_lat,
+        lon=settings.node_lon,
+        configured=False,
+    )
+
+
+def save_node_config(config: NodeConfig) -> None:
+    _CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+    _CONFIG_FILE.write_text(config.model_dump_json(indent=2))
+    logger.info("Node config saved.")
+
+
+def apply_system_config(system_config: SystemConfig) -> bool:
+    """Write the OP25-compatible config blob to /configs/active.cfg.json."""
+    try:
+        active_cfg = Path(settings.config_path) / "active.cfg.json"
+        active_cfg.write_text(json.dumps(system_config.config, indent=2))
+        logger.info(f"System config applied: {system_config.name}")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to write system config: {e}")
+        return False

drb-edge-node/app/internal/credentials.py

@@ -0,0 +1,39 @@
+"""
+Manages the persisted node API key.
+
+The key is provisioned by the C2 server after an admin approves the node.
+It arrives via MQTT and is saved to /configs/credentials.json so it survives
+container restarts.
+"""
+import json
+from pathlib import Path
+from app.config import settings
+from app.internal.logger import logger
+
+_CREDS_FILE = Path(settings.config_path) / "credentials.json"
+_api_key: str | None = None
+
+
+def load() -> None:
+    """Load persisted credentials from disk on startup."""
+    global _api_key
+    if _CREDS_FILE.exists():
+        try:
+            data = json.loads(_CREDS_FILE.read_text())
+            _api_key = data.get("api_key")
+            if _api_key:
+                logger.info("Node credentials loaded from disk.")
+        except Exception as e:
+            logger.warning(f"Could not read credentials file: {e}")
+
+
+def get_api_key() -> str | None:
+    return _api_key
+
+
+def save_api_key(key: str) -> None:
+    global _api_key
+    _api_key = key
+    _CREDS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    _CREDS_FILE.write_text(json.dumps({"api_key": key}))
+    logger.info("Node API key saved to disk.")

drb-edge-node/app/internal/discord_radio.py

@@ -0,0 +1,119 @@
+import asyncio
+from typing import Optional
+import discord
+from discord.ext import commands
+from app.config import settings
+from app.internal.logger import logger
+
+BOT_READY_TIMEOUT = 15  # seconds to wait for Discord bot to become ready
+
+
+class RadioBot:
+    def __init__(self):
+        self._bot: Optional[commands.Bot] = None
+        self._voice_client: Optional[discord.VoiceClient] = None
+        self._task: Optional[asyncio.Task] = None
+        self._ready_event: Optional[asyncio.Event] = None
+        self._current_token: Optional[str] = None
+        self._icecast_url = (
+            f"http://{settings.icecast_host}:{settings.icecast_port}{settings.icecast_mount}"
+        )
+
+    async def join(self, guild_id: int, channel_id: int, token: str) -> bool:
+        # (Re)start the bot if the token changed or the bot isn't running
+        if self._current_token != token or not self._is_bot_running():
+            if not await self._start_bot(token):
+                return False
+
+        guild = self._bot.get_guild(guild_id)
+        if not guild:
+            logger.error(f"Guild {guild_id} not found — bot may not be a member.")
+            return False
+
+        channel = guild.get_channel(channel_id)
+        if not isinstance(channel, discord.VoiceChannel):
+            logger.error(f"Channel {channel_id} is not a voice channel.")
+            return False
+
+        try:
+            if self._voice_client and self._voice_client.is_connected():
+                await self._voice_client.disconnect(force=True)
+            self._voice_client = await channel.connect()
+            self._play_stream()
+            logger.info(f"Streaming to #{channel.name} in {guild.name}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to join voice channel: {e}")
+            return False
+
+    async def leave(self) -> bool:
+        if self._voice_client and self._voice_client.is_connected():
+            try:
+                await self._voice_client.disconnect(force=True)
+                self._voice_client = None
+                logger.info("Disconnected from voice channel.")
+                return True
+            except Exception as e:
+                logger.error(f"Failed to disconnect: {e}")
+        return False
+
+    async def stop(self):
+        await self.leave()
+        if self._task:
+            self._task.cancel()
+        if self._bot:
+            await self._bot.close()
+        self._bot = None
+        self._task = None
+        self._current_token = None
+        self._ready_event = None
+
+    def _play_stream(self):
+        if not self._voice_client:
+            return
+        source = discord.FFmpegPCMAudio(
+            self._icecast_url,
+            before_options="-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5",
+        )
+        self._voice_client.play(
+            discord.PCMVolumeTransformer(source, volume=1.0),
+            after=lambda e: logger.error(f"Stream ended unexpectedly: {e}") if e else None,
+        )
+
+    async def _start_bot(self, token: str) -> bool:
+        await self.stop()  # clean up any previous instance
+
+        intents = discord.Intents.default()
+        intents.voice_states = True
+        self._bot = commands.Bot(command_prefix="!", intents=intents)
+        self._ready_event = asyncio.Event()
+        self._current_token = token
+
+        @self._bot.event
+        async def on_ready():
+            logger.info(f"Discord bot ready: {self._bot.user} ({self._bot.user.id})")
+            self._ready_event.set()
+
+        self._task = asyncio.create_task(self._bot.start(token))
+
+        try:
+            await asyncio.wait_for(self._ready_event.wait(), timeout=BOT_READY_TIMEOUT)
+            return True
+        except asyncio.TimeoutError:
+            logger.error("Timed out waiting for Discord bot to become ready.")
+            await self.stop()
+            return False
+
+    def _is_bot_running(self) -> bool:
+        return (
+            self._bot is not None
+            and self._task is not None
+            and not self._task.done()
+        )
+
+    @property
+    def is_connected(self) -> bool:
+        return self._voice_client is not None and self._voice_client.is_connected()
+
+
+radio_bot = RadioBot()

drb-edge-node/app/internal/logger.py

@@ -0,0 +1,10 @@
+import logging
+import sys
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)],
+)
+
+logger = logging.getLogger("drb-edge-node")

drb-edge-node/app/internal/metadata_watcher.py

@@ -0,0 +1,127 @@
+import asyncio
+import uuid
+from datetime import datetime, timezone
+from typing import Optional, Callable, Awaitable
+from app.internal.op25_client import op25_client
+from app.internal.logger import logger
+
+CallbackFn = Callable[[dict], Awaitable[None]]
+
+HANG_THRESHOLD = 3   # polls before declaring a call ended (1 poll/sec → 3s hang time)
+POLL_INTERVAL = 1.0  # seconds
+
+
+class MetadataWatcher:
+    def __init__(self):
+        self._running = False
+        self._current_tgid: Optional[int] = None
+        self._hang_counter: int = 0
+        self._active_call_id: Optional[str] = None
+        self._call_started_at: Optional[datetime] = None
+
+        # Set these before calling start()
+        self.on_call_start: Optional[CallbackFn] = None
+        self.on_call_end: Optional[CallbackFn] = None
+
+    async def start(self):
+        self._running = True
+        asyncio.create_task(self._poll_loop())
+        logger.info("Metadata watcher started.")
+
+    async def stop(self):
+        self._running = False
+        if self._active_call_id:
+            await self._end_call()
+
+    async def _poll_loop(self):
+        while self._running:
+            try:
+                await self._tick()
+            except Exception as e:
+                logger.warning(f"Metadata poll error: {e}")
+            await asyncio.sleep(POLL_INTERVAL)
+
+    async def _tick(self):
+        status = await op25_client.get_terminal_status()
+
+        if not status:
+            # OP25 not responding — hang-out any active call
+            if self._active_call_id:
+                self._hang_counter += 1
+                if self._hang_counter >= HANG_THRESHOLD:
+                    await self._end_call()
+            return
+
+        # OP25 terminal returns either a list of channels or a single dict
+        channels = status if isinstance(status, list) else [status]
+        active_tgid: Optional[int] = None
+        active_meta: dict = {}
+
+        for ch in channels:
+            tgid = ch.get("tgid") or ch.get("tg_id")
+            if tgid and str(tgid) not in ("0", "", "None"):
+                active_tgid = int(tgid)
+                active_meta = ch
+                break
+
+        if active_tgid:
+            self._hang_counter = 0
+            if self._current_tgid != active_tgid:
+                # Talkgroup changed — close previous call and open a new one
+                if self._active_call_id:
+                    await self._end_call()
+                self._current_tgid = active_tgid
+                await self._start_call(active_tgid, active_meta)
+        else:
+            # No active talkgroup
+            if self._active_call_id:
+                self._hang_counter += 1
+                if self._hang_counter >= HANG_THRESHOLD:
+                    await self._end_call()
+
+    async def _start_call(self, tgid: int, meta: dict):
+        self._active_call_id = str(uuid.uuid4())
+        self._call_started_at = datetime.now(timezone.utc)
+        payload = {
+            "call_id": self._active_call_id,
+            "tgid": tgid,
+            "tgid_name": meta.get("tag") or meta.get("tgid_tag") or "",
+            "freq": meta.get("freq"),
+            "srcaddr": meta.get("srcaddr"),
+            "started_at": self._call_started_at.isoformat(),
+        }
+        logger.info(f"Call start: tgid={tgid} id={self._active_call_id}")
+        if self.on_call_start:
+            await self.on_call_start(payload)
+
+    async def _end_call(self):
+        if not self._active_call_id:
+            return
+        payload = {
+            "call_id": self._active_call_id,
+            "tgid": self._current_tgid,
+            "started_at": self._call_started_at.isoformat() if self._call_started_at else None,
+            "ended_at": datetime.now(timezone.utc).isoformat(),
+        }
+        logger.info(f"Call end: id={self._active_call_id}")
+        self._active_call_id = None
+        self._current_tgid = None
+        self._hang_counter = 0
+        self._call_started_at = None
+        if self.on_call_end:
+            await self.on_call_end(payload)
+
+    @property
+    def active_call_id(self) -> Optional[str]:
+        return self._active_call_id
+
+    @property
+    def current_tgid(self) -> Optional[int]:
+        return self._current_tgid
+
+    @property
+    def is_active(self) -> bool:
+        return self._active_call_id is not None
+
+
+metadata_watcher = MetadataWatcher()

drb-edge-node/app/internal/mqtt_manager.py

@@ -0,0 +1,159 @@
+import asyncio
+import json
+from datetime import datetime, timezone
+from typing import Optional, Callable, Awaitable, Dict, Any
+import paho.mqtt.client as mqtt
+from app.config import settings
+from app.internal.logger import logger
+
+CommandCallback = Callable[[Dict[str, Any]], Awaitable[None]]
+ConfigCallback = Callable[[Dict[str, Any]], Awaitable[None]]
+ApiKeyCallback = Callable[[Dict[str, Any]], Awaitable[None]]
+
+
+class MQTTManager:
+    def __init__(self):
+        self._client: Optional[mqtt.Client] = None
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+        self._connected = False
+        self._connect_task: Optional[asyncio.Task] = None
+
+        self.on_command: Optional[CommandCallback] = None
+        self.on_config_push: Optional[ConfigCallback] = None
+        self.on_api_key: Optional[ApiKeyCallback] = None
+
+        nid = settings.node_id
+        self._t_checkin   = f"nodes/{nid}/checkin"
+        self._t_status    = f"nodes/{nid}/status"
+        self._t_metadata  = f"nodes/{nid}/metadata"
+        self._t_commands  = f"nodes/{nid}/commands"
+        self._t_config    = f"nodes/{nid}/config"
+        self._t_api_key   = f"nodes/{nid}/api_key"
+        self._t_discovery = "nodes/discovery/request"
+
+    def _build_client(self) -> mqtt.Client:
+        client = mqtt.Client(
+            callback_api_version=mqtt.CallbackAPIVersion.VERSION2,
+            client_id=settings.node_id,
+        )
+        if settings.mqtt_user:
+            client.username_pw_set(settings.mqtt_user, settings.mqtt_pass)
+
+        lwt = json.dumps({
+            "node_id": settings.node_id,
+            "status": "offline",
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+        })
+        client.will_set(self._t_status, lwt, qos=1, retain=True)
+
+        client.reconnect_delay_set(min_delay=2, max_delay=60)
+        client.on_connect    = self._on_connect
+        client.on_disconnect = self._on_disconnect
+        client.on_message    = self._on_message
+        return client
+
+    def _on_connect(self, client, userdata, flags, reason_code, properties):
+        if reason_code == 0:
+            self._connected = True
+            client.subscribe(self._t_commands, qos=1)
+            client.subscribe(self._t_config, qos=1)
+            client.subscribe(self._t_api_key, qos=2)
+            client.subscribe(self._t_discovery, qos=0)
+            logger.info("MQTT connected.")
+            asyncio.run_coroutine_threadsafe(self._publish_checkin(), self._loop)
+        else:
+            logger.error(f"MQTT connect refused: {reason_code}")
+
+    def _on_disconnect(self, client, userdata, disconnect_flags, reason_code, properties):
+        self._connected = False
+        logger.warning(f"MQTT disconnected: {reason_code}")
+
+    def _on_message(self, client, userdata, msg):
+        try:
+            payload = json.loads(msg.payload.decode())
+        except Exception:
+            payload = msg.payload.decode()
+
+        if msg.topic == self._t_commands and self.on_command:
+            asyncio.run_coroutine_threadsafe(self.on_command(payload), self._loop)
+        elif msg.topic == self._t_config and self.on_config_push:
+            asyncio.run_coroutine_threadsafe(self.on_config_push(payload), self._loop)
+        elif msg.topic == self._t_api_key and self.on_api_key:
+            asyncio.run_coroutine_threadsafe(self.on_api_key(payload), self._loop)
+        elif msg.topic == self._t_discovery:
+            asyncio.run_coroutine_threadsafe(self._publish_checkin(), self._loop)
+
+    async def connect(self):
+        self._loop = asyncio.get_event_loop()
+        self._client = self._build_client()
+        self._connect_task = asyncio.create_task(self._connect_with_retry())
+
+    async def _connect_with_retry(self):
+        """Attempt the initial TCP connect, retrying with backoff until it succeeds."""
+        delay = 5
+        logger.info(f"MQTT connecting to {settings.mqtt_broker}:{settings.mqtt_port}")
+        while True:
+            try:
+                self._client.connect(settings.mqtt_broker, settings.mqtt_port, keepalive=60)
+                self._client.loop_start()
+                # paho loop_start + reconnect_delay_set handles all subsequent reconnects
+                return
+            except Exception as e:
+                logger.warning(f"MQTT connect failed ({e}) — retrying in {delay}s")
+                await asyncio.sleep(delay)
+                delay = min(delay * 2, 60)
+
+    async def disconnect(self):
+        if self._connect_task:
+            self._connect_task.cancel()
+        if self._client:
+            await self.publish_status("offline")
+            self._client.loop_stop()
+            self._client.disconnect()
+
+    async def publish_status(self, status: str, extra: dict = None):
+        payload = {
+            "node_id": settings.node_id,
+            "status": status,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            **(extra or {}),
+        }
+        self._publish(self._t_status, payload, qos=1, retain=True)
+
+    async def publish_metadata(self, event_type: str, data: dict):
+        payload = {
+            "event": event_type,
+            "node_id": settings.node_id,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            **data,
+        }
+        self._publish(self._t_metadata, payload, qos=1)
+
+    async def _publish_checkin(self):
+        payload = {
+            "node_id": settings.node_id,
+            "name": settings.node_name,
+            "lat": settings.node_lat,
+            "lon": settings.node_lon,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+        }
+        self._publish(self._t_checkin, payload, qos=1)
+
+    def _publish(self, topic: str, payload: dict, qos: int = 0, retain: bool = False):
+        if self._client and self._connected:
+            self._client.publish(topic, json.dumps(payload), qos=qos, retain=retain)
+        else:
+            logger.debug(f"MQTT not connected, dropping publish to {topic}")
+
+    async def heartbeat_loop(self):
+        while True:
+            if self._connected:
+                await self._publish_checkin()
+            await asyncio.sleep(30)
+
+    @property
+    def is_connected(self) -> bool:
+        return self._connected
+
+
+mqtt_manager = MQTTManager()

drb-edge-node/app/internal/op25_client.py

@@ -0,0 +1,63 @@
+import httpx
+from typing import Optional, Dict, Any
+from app.config import settings
+from app.internal.logger import logger
+
+
+class OP25Client:
+    def __init__(self):
+        self.api_url = settings.op25_api_url
+        self.terminal_url = settings.op25_terminal_url
+
+    async def start(self) -> bool:
+        try:
+            async with httpx.AsyncClient(timeout=10) as client:
+                r = await client.post(f"{self.api_url}/op25/start")
+                r.raise_for_status()
+                return True
+        except Exception as e:
+            logger.error(f"OP25 start failed: {e}")
+            return False
+
+    async def stop(self) -> bool:
+        try:
+            async with httpx.AsyncClient(timeout=10) as client:
+                r = await client.post(f"{self.api_url}/op25/stop")
+                r.raise_for_status()
+                return True
+        except Exception as e:
+            logger.error(f"OP25 stop failed: {e}")
+            return False
+
+    async def status(self) -> Optional[Dict[str, Any]]:
+        try:
+            async with httpx.AsyncClient(timeout=5) as client:
+                r = await client.get(f"{self.api_url}/op25/status")
+                r.raise_for_status()
+                return r.json()
+        except Exception as e:
+            logger.error(f"OP25 status failed: {e}")
+            return None
+
+    async def generate_config(self, config: Dict[str, Any]) -> bool:
+        try:
+            async with httpx.AsyncClient(timeout=10) as client:
+                r = await client.post(f"{self.api_url}/op25/generate-config", json=config)
+                r.raise_for_status()
+                return True
+        except Exception as e:
+            logger.error(f"OP25 generate-config failed: {e}")
+            return False
+
+    async def get_terminal_status(self) -> Optional[Any]:
+        """Poll the OP25 HTTP terminal for current call metadata."""
+        try:
+            async with httpx.AsyncClient(timeout=3) as client:
+                r = await client.get(f"{self.terminal_url}/0/status.json")
+                r.raise_for_status()
+                return r.json()
+        except Exception:
+            return None
+
+
+op25_client = OP25Client()

drb-edge-node/app/main.py

@@ -0,0 +1,141 @@
+import asyncio
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from app.config import settings
+from app.models import SystemConfig
+from app.internal.logger import logger
+from app.internal.mqtt_manager import mqtt_manager
+from app.internal import credentials
+from app.internal.metadata_watcher import metadata_watcher
+from app.internal.call_recorder import call_recorder
+from app.internal.discord_radio import radio_bot
+from app.internal.config_manager import (
+    load_node_config,
+    save_node_config,
+    apply_system_config,
+)
+from app.routers import api, ui
+
+
+# ---------------------------------------------------------------------------
+# Event handlers wired up at startup
+# ---------------------------------------------------------------------------
+
+async def on_call_start(data: dict):
+    await mqtt_manager.publish_status("recording")
+    await mqtt_manager.publish_metadata("call_start", data)
+    await call_recorder.start_recording(data["call_id"])
+
+
+async def on_call_end(data: dict):
+    file_path = await call_recorder.stop_recording()
+    if file_path:
+        audio_url = await call_recorder.upload_recording(file_path, data["call_id"])
+        if audio_url:
+            data["audio_url"] = audio_url
+    await mqtt_manager.publish_metadata("call_end", data)
+    await mqtt_manager.publish_status("online")
+
+
+async def on_command(payload: dict):
+    action = payload.get("action")
+    logger.info(f"Command received: {action}")
+
+    if action == "discord_join":
+        token = payload.get("token")
+        if not token:
+            logger.error("discord_join command missing token — ignoring.")
+            return
+        await radio_bot.join(
+            guild_id=int(payload["guild_id"]),
+            channel_id=int(payload["channel_id"]),
+            token=token,
+        )
+    elif action == "discord_leave":
+        await radio_bot.leave()
+    elif action == "op25_restart":
+        from app.internal.op25_client import op25_client
+        await op25_client.stop()
+        await asyncio.sleep(2)
+        await op25_client.start()
+    else:
+        logger.warning(f"Unknown command: {action}")
+
+
+async def on_api_key(payload: dict):
+    key = payload.get("api_key")
+    if key:
+        credentials.save_api_key(key)
+        logger.info("Node API key received and saved.")
+
+
+async def on_config_push(payload: dict):
+    """C2 pushes a system config — apply it and restart OP25 with the new settings."""
+    try:
+        config = SystemConfig(**payload)
+    except Exception as e:
+        logger.error(f"Invalid config push payload: {e}")
+        return
+
+    node_cfg = load_node_config()
+    node_cfg.assigned_system_id = config.system_id
+    node_cfg.system_config = config
+    node_cfg.configured = True
+    save_node_config(node_cfg)
+    apply_system_config(config)
+
+    # Restart OP25 so it picks up the new config
+    from app.internal.op25_client import op25_client
+    await op25_client.stop()
+    await asyncio.sleep(2)
+    await op25_client.start()
+
+    logger.info(f"Config push applied: {config.name}")
+
+
+# ---------------------------------------------------------------------------
+# App lifecycle
+# ---------------------------------------------------------------------------
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    logger.info(f"Edge node starting — ID: {settings.node_id}")
+
+    # Load persisted credentials (API key provisioned by C2 after approval)
+    credentials.load()
+
+    # Wire callbacks
+    metadata_watcher.on_call_start = on_call_start
+    metadata_watcher.on_call_end = on_call_end
+    mqtt_manager.on_command = on_command
+    mqtt_manager.on_config_push = on_config_push
+    mqtt_manager.on_api_key = on_api_key
+
+    # Start services (radio_bot starts on-demand when a discord_join command arrives)
+    await mqtt_manager.connect()
+    await metadata_watcher.start()
+
+    # Report initial status and resume OP25 if node was already configured before this restart
+    node_cfg = load_node_config()
+    initial_status = "online" if node_cfg.configured else "unconfigured"
+    await mqtt_manager.publish_status(initial_status)
+
+    if node_cfg.configured:
+        from app.internal.op25_client import op25_client
+        logger.info("Node is configured — starting OP25.")
+        await op25_client.start()
+
+    heartbeat_task = asyncio.create_task(mqtt_manager.heartbeat_loop())
+
+    yield  # --- app running ---
+
+    logger.info("Edge node shutting down.")
+    heartbeat_task.cancel()
+    await metadata_watcher.stop()
+    await radio_bot.stop()
+    await mqtt_manager.disconnect()
+
+
+app = FastAPI(title=f"DRB Edge Node — {settings.node_id}", lifespan=lifespan)
+app.include_router(api.router)
+app.include_router(ui.router)

drb-edge-node/app/models.py

@@ -0,0 +1,51 @@
+from pydantic import BaseModel
+from typing import Optional, Dict, Any
+from enum import Enum
+from datetime import datetime
+
+
+class NodeStatus(str, Enum):
+    ONLINE = "online"
+    OFFLINE = "offline"
+    RECORDING = "recording"
+    UNCONFIGURED = "unconfigured"
+
+
+class CallStatus(str, Enum):
+    ACTIVE = "active"
+    ENDED = "ended"
+
+
+class SystemConfig(BaseModel):
+    system_id: str
+    name: str
+    type: str  # P25, DMR, NBFM
+    config: Dict[str, Any]  # OP25-compatible config blob passed through to op25-container
+
+
+class NodeConfig(BaseModel):
+    node_id: str
+    node_name: str
+    lat: float
+    lon: float
+    assigned_system_id: Optional[str] = None
+    system_config: Optional[SystemConfig] = None
+    configured: bool = False
+
+
+class CallEvent(BaseModel):
+    call_id: str
+    node_id: str
+    system_id: Optional[str] = None
+    talkgroup_id: Optional[int] = None
+    talkgroup_name: Optional[str] = None
+    started_at: datetime
+    ended_at: Optional[datetime] = None
+    audio_url: Optional[str] = None
+    status: CallStatus = CallStatus.ACTIVE
+
+
+class DiscordCommand(BaseModel):
+    action: str  # "join" or "leave"
+    guild_id: Optional[str] = None
+    channel_id: Optional[str] = None

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

@@ -0,0 +1,82 @@
+from fastapi import APIRouter, HTTPException
+from app.config import settings
+from app.models import SystemConfig
+from app.internal.op25_client import op25_client
+from app.internal.config_manager import load_node_config, save_node_config, apply_system_config
+from app.internal.call_recorder import call_recorder
+from app.internal.discord_radio import radio_bot
+from app.internal.metadata_watcher import metadata_watcher
+
+router = APIRouter(prefix="/api", tags=["api"])
+
+
+@router.get("/status")
+async def get_status():
+    node_cfg = load_node_config()
+    op25_status = await op25_client.status()
+    return {
+        "node_id": settings.node_id,
+        "node_name": settings.node_name,
+        "lat": settings.node_lat,
+        "lon": settings.node_lon,
+        "configured": node_cfg.configured,
+        "assigned_system_id": node_cfg.assigned_system_id,
+        "is_recording": call_recorder.is_recording,
+        "active_tgid": metadata_watcher.current_tgid,
+        "active_call_id": metadata_watcher.active_call_id,
+        "discord_connected": radio_bot.is_connected,
+        "icecast_url": (
+            f"http://{settings.icecast_host}:{settings.icecast_port}{settings.icecast_mount}"
+        ),
+        "op25": op25_status,
+    }
+
+
+@router.post("/op25/start")
+async def start_op25():
+    ok = await op25_client.start()
+    if not ok:
+        raise HTTPException(500, "Failed to start OP25")
+    return {"ok": True}
+
+
+@router.post("/op25/stop")
+async def stop_op25():
+    ok = await op25_client.stop()
+    if not ok:
+        raise HTTPException(500, "Failed to stop OP25")
+    return {"ok": True}
+
+
+@router.get("/config")
+async def get_config():
+    return load_node_config()
+
+
+@router.post("/config/system")
+async def set_system_config(config: SystemConfig):
+    """
+    Apply a system config locally — called by the web UI or pushed by C2.
+    Writes the OP25 config and persists the node config.
+    """
+    node_cfg = load_node_config()
+    node_cfg.assigned_system_id = config.system_id
+    node_cfg.system_config = config
+    node_cfg.configured = True
+    save_node_config(node_cfg)
+    apply_system_config(config)
+    return {"ok": True}
+
+
+@router.post("/discord/join")
+async def discord_join(guild_id: int, channel_id: int):
+    ok = await radio_bot.join(guild_id, channel_id)
+    if not ok:
+        raise HTTPException(500, "Failed to join voice channel")
+    return {"ok": True}
+
+
+@router.post("/discord/leave")
+async def discord_leave():
+    await radio_bot.leave()
+    return {"ok": True}

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

@@ -0,0 +1,12 @@
+from pathlib import Path
+from fastapi import APIRouter
+from fastapi.responses import HTMLResponse
+
+router = APIRouter(tags=["ui"])
+
+_TEMPLATE = Path(__file__).parent.parent / "templates" / "index.html"
+
+
+@router.get("/", response_class=HTMLResponse)
+async def index():
+    return _TEMPLATE.read_text()

drb-edge-node/app/templates/index.html

@@ -0,0 +1,196 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>DRB Edge Node</title>
+  <style>
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+    body {
+      font-family: ui-monospace, "Cascadia Code", "Source Code Pro", monospace;
+      background: #0f1117;
+      color: #e2e8f0;
+      min-height: 100vh;
+      padding: 2rem;
+    }
+
+    h1 { font-size: 1.25rem; font-weight: 600; color: #f8fafc; margin-bottom: 0.25rem; }
+    .subtitle { font-size: 0.8rem; color: #64748b; margin-bottom: 2rem; }
+
+    .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); gap: 1rem; }
+
+    .card {
+      background: #1e2130;
+      border: 1px solid #2d3250;
+      border-radius: 8px;
+      padding: 1.25rem;
+    }
+    .card-title {
+      font-size: 0.7rem;
+      text-transform: uppercase;
+      letter-spacing: 0.08em;
+      color: #64748b;
+      margin-bottom: 0.75rem;
+    }
+
+    .badge {
+      display: inline-block;
+      padding: 0.2rem 0.6rem;
+      border-radius: 999px;
+      font-size: 0.75rem;
+      font-weight: 600;
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+    }
+    .badge-online    { background: #14532d; color: #4ade80; }
+    .badge-offline   { background: #450a0a; color: #f87171; }
+    .badge-recording { background: #431407; color: #fb923c; animation: pulse 1.5s infinite; }
+    .badge-unconfigured { background: #1e1b4b; color: #818cf8; }
+
+    @keyframes pulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.6; } }
+
+    .row { display: flex; justify-content: space-between; align-items: center; padding: 0.4rem 0; border-bottom: 1px solid #2d3250; }
+    .row:last-child { border-bottom: none; }
+    .row .label { font-size: 0.78rem; color: #94a3b8; }
+    .row .value { font-size: 0.78rem; color: #e2e8f0; text-align: right; max-width: 60%; word-break: break-all; }
+
+    .listen-btn {
+      display: block;
+      width: 100%;
+      margin-top: 0.75rem;
+      padding: 0.6rem;
+      background: #2563eb;
+      color: #fff;
+      border: none;
+      border-radius: 6px;
+      font-size: 0.8rem;
+      font-family: inherit;
+      cursor: pointer;
+      text-align: center;
+      text-decoration: none;
+    }
+    .listen-btn:hover { background: #1d4ed8; }
+
+    .config-section { margin-top: 1.5rem; }
+    .config-section h2 { font-size: 0.85rem; color: #94a3b8; margin-bottom: 1rem; }
+
+    .alert {
+      background: #1e1b4b;
+      border: 1px solid #4338ca;
+      border-radius: 6px;
+      padding: 0.75rem 1rem;
+      font-size: 0.8rem;
+      color: #818cf8;
+      margin-bottom: 1rem;
+    }
+
+    .updated { font-size: 0.7rem; color: #475569; margin-top: 2rem; }
+  </style>
+</head>
+<body>
+  <h1 id="node-name">DRB Edge Node</h1>
+  <p class="subtitle" id="node-id">Loading…</p>
+
+  <div class="grid">
+    <div class="card">
+      <div class="card-title">Status</div>
+      <div class="row">
+        <span class="label">State</span>
+        <span class="value"><span id="status-badge" class="badge">—</span></span>
+      </div>
+      <div class="row">
+        <span class="label">MQTT</span>
+        <span class="value" id="mqtt-status">—</span>
+      </div>
+      <div class="row">
+        <span class="label">Discord</span>
+        <span class="value" id="discord-status">—</span>
+      </div>
+      <div class="row">
+        <span class="label">Recording</span>
+        <span class="value" id="recording-status">—</span>
+      </div>
+    </div>
+
+    <div class="card">
+      <div class="card-title">Current Call</div>
+      <div class="row">
+        <span class="label">Talkgroup</span>
+        <span class="value" id="tgid">—</span>
+      </div>
+      <div class="row">
+        <span class="label">Call ID</span>
+        <span class="value" id="call-id">—</span>
+      </div>
+      <div class="row">
+        <span class="label">System</span>
+        <span class="value" id="system-id">—</span>
+      </div>
+      <div class="row">
+        <span class="label">OP25</span>
+        <span class="value" id="op25-status">—</span>
+      </div>
+    </div>
+
+    <div class="card">
+      <div class="card-title">Node Info</div>
+      <div class="row">
+        <span class="label">Lat / Lon</span>
+        <span class="value" id="location">—</span>
+      </div>
+      <div class="row">
+        <span class="label">Configured</span>
+        <span class="value" id="configured">—</span>
+      </div>
+      <a id="icecast-link" class="listen-btn" href="#" target="_blank">Listen via Icecast</a>
+    </div>
+  </div>
+
+  <div id="unconfigured-banner" class="config-section" style="display:none">
+    <div class="alert">
+      This node has not been assigned a system yet. Connect it to a C2 server or configure it manually via the API (<code>POST /api/config/system</code>).
+    </div>
+  </div>
+
+  <p class="updated">Last updated: <span id="last-updated">—</span></p>
+
+  <script>
+    async function refresh() {
+      try {
+        const r = await fetch('/api/status');
+        if (!r.ok) return;
+        const d = await r.json();
+
+        document.getElementById('node-name').textContent = d.node_name || 'DRB Edge Node';
+        document.getElementById('node-id').textContent = d.node_id || '';
+
+        const status = d.is_recording ? 'recording' : (d.configured ? 'online' : 'unconfigured');
+        const badge = document.getElementById('status-badge');
+        badge.textContent = status;
+        badge.className = 'badge badge-' + status;
+
+        document.getElementById('discord-status').textContent = d.discord_connected ? 'Connected' : 'Not connected';
+        document.getElementById('recording-status').textContent = d.is_recording ? 'Yes' : 'No';
+        document.getElementById('tgid').textContent = d.active_tgid ?? '—';
+        document.getElementById('call-id').textContent = d.active_call_id ? d.active_call_id.slice(0, 8) + '…' : '—';
+        document.getElementById('system-id').textContent = d.assigned_system_id ?? '—';
+        document.getElementById('op25-status').textContent = d.op25?.running ? 'Running' : 'Stopped';
+        document.getElementById('location').textContent = `${d.lat}, ${d.lon}`;
+        document.getElementById('configured').textContent = d.configured ? 'Yes' : 'No';
+
+        const icecastLink = document.getElementById('icecast-link');
+        icecastLink.href = d.icecast_url || '#';
+
+        document.getElementById('unconfigured-banner').style.display = d.configured ? 'none' : 'block';
+        document.getElementById('last-updated').textContent = new Date().toLocaleTimeString();
+      } catch (e) {
+        console.error('Status fetch failed:', e);
+      }
+    }
+
+    refresh();
+    setInterval(refresh, 3000);
+  </script>
+</body>
+</html>