Initial commit — DRB server stack

Includes c2-core (FastAPI/MQTT/Firestore), discord-bot (slash commands),
frontend (Next.js admin UI), and mosquitto config.

drb-c2-core/app/routers/calls.py

@@ -0,0 +1,29 @@
+from fastapi import APIRouter, HTTPException, Query
+from typing import Optional
+from app.internal import firestore as fstore
+
+router = APIRouter(prefix="/calls", tags=["calls"])
+
+
+@router.get("")
+async def list_calls(
+    node_id: Optional[str] = Query(None),
+    status: Optional[str] = Query(None),
+    system_id: Optional[str] = Query(None),
+):
+    filters = {}
+    if node_id:
+        filters["node_id"] = node_id
+    if status:
+        filters["status"] = status
+    if system_id:
+        filters["system_id"] = system_id
+    return await fstore.collection_list("calls", **filters)
+
+
+@router.get("/{call_id}")
+async def get_call(call_id: str):
+    call = await fstore.doc_get("calls", call_id)
+    if not call:
+        raise HTTPException(404, f"Call '{call_id}' not found.")
+    return call

drb-c2-core/app/routers/nodes.py

@@ -0,0 +1,91 @@
+import secrets
+from fastapi import APIRouter, HTTPException, Depends
+from app.models import CommandPayload
+from app.internal import firestore as fstore
+from app.internal.mqtt_handler import mqtt_handler
+from app.internal.auth import require_admin_token
+from app.routers.tokens import assign_token, release_token
+
+router = APIRouter(prefix="/nodes", tags=["nodes"])
+
+
+@router.get("")
+async def list_nodes():
+    return await fstore.collection_list("nodes")
+
+
+@router.get("/{node_id}")
+async def get_node(node_id: str):
+    node = await fstore.doc_get("nodes", node_id)
+    if not node:
+        raise HTTPException(404, f"Node '{node_id}' not found.")
+    return node
+
+
+@router.post("/{node_id}/approve")
+async def approve_node(node_id: str, _: dict = Depends(require_admin_token)):
+    node = await fstore.doc_get("nodes", node_id)
+    if not node:
+        raise HTTPException(404, f"Node '{node_id}' not found.")
+
+    api_key = secrets.token_hex(32)
+    await fstore.doc_set("node_keys", node_id, {"node_id": node_id, "api_key": api_key}, merge=False)
+    await fstore.doc_update("nodes", node_id, {"approval_status": "approved"})
+    mqtt_handler.publish_node_key(node_id, api_key)
+    return {"ok": True}
+
+
+@router.post("/{node_id}/reject")
+async def reject_node(node_id: str, _: dict = Depends(require_admin_token)):
+    node = await fstore.doc_get("nodes", node_id)
+    if not node:
+        raise HTTPException(404, f"Node '{node_id}' not found.")
+    await fstore.doc_update("nodes", node_id, {"approval_status": "rejected"})
+    return {"ok": True}
+
+
+@router.post("/{node_id}/command")
+async def send_command(node_id: str, cmd: CommandPayload):
+    node = await fstore.doc_get("nodes", node_id)
+    if not node:
+        raise HTTPException(404, f"Node '{node_id}' not found.")
+
+    payload = cmd.model_dump(exclude_none=True)
+
+    if cmd.action == "discord_join":
+        token = await assign_token(node_id)
+        if not token:
+            raise HTTPException(503, "No Discord bot tokens available in the pool.")
+        payload["token"] = token
+
+    elif cmd.action == "discord_leave":
+        await release_token(node_id)
+
+    mqtt_handler.send_command(node_id, payload)
+    return {"ok": True}
+
+
+@router.post("/{node_id}/config/{system_id}")
+async def assign_system(node_id: str, system_id: str):
+    """
+    Assign a system to a node. Fetches the system config from Firestore
+    and pushes it to the node via MQTT, then marks the node as configured.
+    """
+    node = await fstore.doc_get("nodes", node_id)
+    if not node:
+        raise HTTPException(404, f"Node '{node_id}' not found.")
+
+    system = await fstore.doc_get("systems", system_id)
+    if not system:
+        raise HTTPException(404, f"System '{system_id}' not found.")
+
+    # Push config to the node via MQTT
+    mqtt_handler.push_config(node_id, system)
+
+    # Update Firestore
+    await fstore.doc_update("nodes", node_id, {
+        "assigned_system_id": system_id,
+        "configured": True,
+    })
+
+    return {"ok": True}

drb-c2-core/app/routers/systems.py

@@ -0,0 +1,44 @@
+import uuid
+from fastapi import APIRouter, HTTPException
+from app.models import SystemCreate, SystemRecord
+from app.internal import firestore as fstore
+
+router = APIRouter(prefix="/systems", tags=["systems"])
+
+
+@router.get("")
+async def list_systems():
+    return await fstore.collection_list("systems")
+
+
+@router.get("/{system_id}")
+async def get_system(system_id: str):
+    system = await fstore.doc_get("systems", system_id)
+    if not system:
+        raise HTTPException(404, f"System '{system_id}' not found.")
+    return system
+
+
+@router.post("", status_code=201)
+async def create_system(body: SystemCreate):
+    system_id = str(uuid.uuid4())
+    doc = SystemRecord(system_id=system_id, **body.model_dump())
+    await fstore.doc_set("systems", system_id, doc.model_dump(), merge=False)
+    return doc
+
+
+@router.put("/{system_id}")
+async def update_system(system_id: str, body: SystemCreate):
+    existing = await fstore.doc_get("systems", system_id)
+    if not existing:
+        raise HTTPException(404, f"System '{system_id}' not found.")
+    await fstore.doc_update("systems", system_id, body.model_dump())
+    return {**existing, **body.model_dump()}
+
+
+@router.delete("/{system_id}", status_code=204)
+async def delete_system(system_id: str):
+    existing = await fstore.doc_get("systems", system_id)
+    if not existing:
+        raise HTTPException(404, f"System '{system_id}' not found.")
+    await fstore.doc_delete("systems", system_id)

drb-c2-core/app/routers/tokens.py

@@ -0,0 +1,103 @@
+import uuid
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime, timezone
+from app.internal import firestore as fstore
+
+router = APIRouter(prefix="/tokens", tags=["tokens"])
+
+
+class TokenCreate(BaseModel):
+    name: str        # friendly label e.g. "DRB Bot 1"
+    token: str       # the actual Discord bot token
+
+
+# ---------------------------------------------------------------------------
+# CRUD
+# ---------------------------------------------------------------------------
+
+@router.get("")
+async def list_tokens():
+    """List all tokens. The actual token string is masked for safety."""
+    tokens = await fstore.collection_list("bot_tokens")
+    return [
+        {**t, "token": t["token"][:10] + "…" + t["token"][-4:]}
+        for t in tokens
+    ]
+
+
+@router.post("", status_code=201)
+async def add_token(body: TokenCreate):
+    token_id = str(uuid.uuid4())
+    doc = {
+        "token_id": token_id,
+        "name": body.name,
+        "token": body.token,
+        "in_use": False,
+        "assigned_node_id": None,
+        "assigned_at": None,
+    }
+    await fstore.doc_set("bot_tokens", token_id, doc, merge=False)
+    return {"token_id": token_id, "name": body.name}
+
+
+@router.delete("/{token_id}", status_code=204)
+async def delete_token(token_id: str):
+    existing = await fstore.doc_get("bot_tokens", token_id)
+    if not existing:
+        raise HTTPException(404, "Token not found.")
+    if existing.get("in_use"):
+        raise HTTPException(409, "Token is currently in use by a node.")
+    await fstore.doc_delete("bot_tokens", token_id)
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers — used by the nodes router, not exposed via HTTP
+# ---------------------------------------------------------------------------
+
+async def assign_token(node_id: str) -> Optional[str]:
+    """
+    Find a free token, mark it as in-use, return the token string.
+    Returns None if no tokens are available.
+    """
+    def _find_free():
+        from app.internal.firestore import db
+        docs = db.collection("bot_tokens").where("in_use", "==", False).limit(1).stream()
+        return [d for d in docs]
+
+    import asyncio
+    results = await asyncio.to_thread(_find_free)
+    if not results:
+        return None
+
+    doc = results[0]
+    token_id = doc.id
+    token_value = doc.to_dict()["token"]
+
+    await fstore.doc_update("bot_tokens", token_id, {
+        "in_use": True,
+        "assigned_node_id": node_id,
+        "assigned_at": datetime.now(timezone.utc),
+    })
+    return token_value
+
+
+async def release_token(node_id: str) -> None:
+    """Free whichever token is currently assigned to this node."""
+    def _find_assigned():
+        from app.internal.firestore import db
+        return [
+            d for d in db.collection("bot_tokens")
+            .where("assigned_node_id", "==", node_id)
+            .stream()
+        ]
+
+    import asyncio
+    results = await asyncio.to_thread(_find_assigned)
+    for doc in results:
+        await fstore.doc_update("bot_tokens", doc.id, {
+            "in_use": False,
+            "assigned_node_id": None,
+            "assigned_at": None,
+        })

drb-c2-core/app/routers/upload.py

@@ -0,0 +1,44 @@
+from typing import Optional
+from fastapi import APIRouter, UploadFile, File, Form, HTTPException, Security
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from app.internal.storage import upload_audio
+from app.internal import firestore as fstore
+from app.internal.logger import logger
+
+router = APIRouter(tags=["upload"])
+
+_bearer = HTTPBearer(auto_error=False)
+
+
+@router.post("/upload")
+async def upload_call_audio(
+    file: UploadFile = File(...),
+    call_id: str = Form(...),
+    node_id: str = Form(...),
+    credentials: Optional[HTTPAuthorizationCredentials] = Security(_bearer),
+):
+    """
+    Receive an audio recording from an edge node.
+    Upload to GCS, update the call document in Firestore with the audio URL.
+    """
+    # Verify the per-node API key
+    if not credentials:
+        raise HTTPException(401, "Missing authorization")
+    key_doc = await fstore.doc_get("node_keys", node_id)
+    if not key_doc or key_doc.get("api_key") != credentials.credentials:
+        raise HTTPException(401, "Invalid node API key")
+
+    data = await file.read()
+    if not data:
+        raise HTTPException(400, "Empty file.")
+
+    filename = f"{call_id}_{file.filename}"
+    audio_url = await upload_audio(data, filename)
+
+    if audio_url:
+        try:
+            await fstore.doc_update("calls", call_id, {"audio_url": audio_url})
+        except Exception as e:
+            logger.warning(f"Could not update call {call_id} with audio_url: {e}")
+
+    return {"url": audio_url}