unchained/mission-control
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(boards): Store gateway config per board

Browse Source 
Move gateway configuration into board settings and wire agent\nprovisioning, heartbeat templates, and gateway status lookups\nto use board-specific gateway settings. Adds board_id on agents\nand UI updates for board-scoped selection.\n\nCo-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Abhimanyu Saharan
2026-02-04 16:04:52 +05:30
parent 12698d0781
commit 4dea771545
20 changed files with 827 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
backend/app/api/gateway.py
View File

@@ -1,43 +1,69 @@
from __future__ import annotations
from fastapi import APIRouter, Body, Depends, HTTPException, status
from fastapi import APIRouter, Body, Depends, HTTPException, Query, status
from sqlmodel import Session
from app.api.deps import require_admin_auth
from app.core.auth import AuthContext
from app.core.config import settings
from app.integrations.openclaw_gateway import (
GatewayConfig,
OpenClawGatewayError,
ensure_session,
get_chat_history,
openclaw_call,
send_message,
)
from app.db.session import get_session
from app.models.boards import Board
router = APIRouter(prefix="/gateway", tags=["gateway"])
def _require_board_config(session: Session, board_id: str | None) -> tuple[Board, GatewayConfig]:
if not board_id:
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail="board_id is required",
)
board = session.get(Board, board_id)
if board is None:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Board not found")
if not board.gateway_url:
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail="Board gateway_url is required",
)
return board, GatewayConfig(url=board.gateway_url, token=board.gateway_token)
@router.get("/status")
async def gateway_status(auth: AuthContext = Depends(require_admin_auth)) -> dict[str, object]:
gateway_url = settings.openclaw_gateway_url or "ws://127.0.0.1:18789"
async def gateway_status(
board_id: str | None = Query(default=None),
session: Session = Depends(get_session),
auth: AuthContext = Depends(require_admin_auth),
) -> dict[str, object]:
board, config = _require_board_config(session, board_id)
try:
sessions = await openclaw_call("sessions.list")
sessions = await openclaw_call("sessions.list", config=config)
if isinstance(sessions, dict):
sessions_list = list(sessions.get("sessions") or [])
else:
sessions_list = list(sessions or [])
main_session = settings.openclaw_main_session_key
main_session = board.gateway_main_session_key or "agent:main:main"
main_session_entry: object | None = None
main_session_error: str | None = None
if main_session:
try:
ensured = await ensure_session(main_session, label="Main Agent")
ensured = await ensure_session(
main_session, config=config, label="Main Agent"
)
if isinstance(ensured, dict):
main_session_entry = ensured.get("entry") or ensured
except OpenClawGatewayError as exc:
main_session_error = str(exc)
return {
"connected": True,
"gateway_url": gateway_url,
"gateway_url": board.gateway_url,
"sessions_count": len(sessions_list),
"sessions": sessions_list,
"main_session_key": main_session,
@@ -47,15 +73,20 @@ async def gateway_status(auth: AuthContext = Depends(require_admin_auth)) -> dic
except OpenClawGatewayError as exc:
return {
"connected": False,
"gateway_url": gateway_url,
"gateway_url": board.gateway_url,
"error": str(exc),
}
@router.get("/sessions")
async def list_sessions(auth: AuthContext = Depends(require_admin_auth)) -> dict[str, object]:
async def list_sessions(
board_id: str | None = Query(default=None),
session: Session = Depends(get_session),
auth: AuthContext = Depends(require_admin_auth),
) -> dict[str, object]:
board, config = _require_board_config(session, board_id)
try:
sessions = await openclaw_call("sessions.list")
sessions = await openclaw_call("sessions.list", config=config)
except OpenClawGatewayError as exc:
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=str(exc)) from exc
if isinstance(sessions, dict):
@@ -63,63 +94,79 @@ async def list_sessions(auth: AuthContext = Depends(require_admin_auth)) -> dict
else:
sessions_list = list(sessions or [])
main_session = settings.openclaw_main_session_key
main_session = board.gateway_main_session_key or "agent:main:main"
main_session_entry: object | None = None
if main_session:
try:
ensured = await ensure_session(main_session, label="Main Agent")
ensured = await ensure_session(
main_session, config=config, label="Main Agent"
)
if isinstance(ensured, dict):
main_session_entry = ensured.get("entry") or ensured
except OpenClawGatewayError:
main_session_entry = None
return {"sessions": sessions_list, "main_session_key": main_session, "main_session": main_session_entry}
return {
"sessions": sessions_list,
"main_session_key": main_session,
"main_session": main_session_entry,
}
@router.get("/sessions/{session_id}")
async def get_session(
session_id: str, auth: AuthContext = Depends(require_admin_auth)
async def get_gateway_session(
session_id: str,
board_id: str | None = Query(default=None),
session: Session = Depends(get_session),
auth: AuthContext = Depends(require_admin_auth),
) -> dict[str, object]:
board, config = _require_board_config(session, board_id)
try:
sessions = await openclaw_call("sessions.list")
sessions = await openclaw_call("sessions.list", config=config)
except OpenClawGatewayError as exc:
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=str(exc)) from exc
if isinstance(sessions, dict):
sessions_list = list(sessions.get("sessions") or [])
else:
sessions_list = list(sessions or [])
main_session = settings.openclaw_main_session_key
main_session = board.gateway_main_session_key or "agent:main:main"
if main_session and not any(
session.get("key") == main_session for session in sessions_list
):
try:
await ensure_session(main_session, label="Main Agent")
refreshed = await openclaw_call("sessions.list")
await ensure_session(main_session, config=config, label="Main Agent")
refreshed = await openclaw_call("sessions.list", config=config)
if isinstance(refreshed, dict):
sessions_list = list(refreshed.get("sessions") or [])
else:
sessions_list = list(refreshed or [])
except OpenClawGatewayError:
pass
session = next((item for item in sessions_list if item.get("key") == session_id), None)
if session is None and main_session and session_id == main_session:
session_entry = next(
(item for item in sessions_list if item.get("key") == session_id), None
)
if session_entry is None and main_session and session_id == main_session:
try:
ensured = await ensure_session(main_session, label="Main Agent")
ensured = await ensure_session(main_session, config=config, label="Main Agent")
if isinstance(ensured, dict):
session = ensured.get("entry") or ensured
session_entry = ensured.get("entry") or ensured
except OpenClawGatewayError:
session = None
if session is None:
session_entry = None
if session_entry is None:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Session not found")
return {"session": session}
return {"session": session_entry}
@router.get("/sessions/{session_id}/history")
async def get_session_history(
session_id: str, auth: AuthContext = Depends(require_admin_auth)
session_id: str,
board_id: str | None = Query(default=None),
session: Session = Depends(get_session),
auth: AuthContext = Depends(require_admin_auth),
) -> dict[str, object]:
_, config = _require_board_config(session, board_id)
try:
history = await get_chat_history(session_id)
history = await get_chat_history(session_id, config=config)
except OpenClawGatewayError as exc:
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=str(exc)) from exc
if isinstance(history, dict) and isinstance(history.get("messages"), list):
@@ -131,6 +178,8 @@ async def get_session_history(
async def send_session_message(
session_id: str,
payload: dict = Body(...),
board_id: str | None = Query(default=None),
session: Session = Depends(get_session),
auth: AuthContext = Depends(require_admin_auth),
) -> dict[str, bool]:
content = payload.get("content")
@@ -138,11 +187,12 @@ async def send_session_message(
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="content is required"
)
board, config = _require_board_config(session, board_id)
try:
main_session = settings.openclaw_main_session_key
main_session = board.gateway_main_session_key or "agent:main:main"
if main_session and session_id == main_session:
await ensure_session(main_session, label="Main Agent")
await send_message(content, session_key=session_id)
await ensure_session(main_session, config=config, label="Main Agent")
await send_message(content, session_key=session_id, config=config)
except OpenClawGatewayError as exc:
raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=str(exc)) from exc
return {"ok": True}