feat: add board group models and update related interfaces
This commit is contained in:
Abhimanyu Saharan
@@ -87,7 +87,9 @@ async def _require_gateway_main(
|
||||
) -> tuple[Gateway, GatewayClientConfig]:
|
||||
session_key = (agent.openclaw_session_id or "").strip()
|
||||
if not session_key:
|
||||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Agent missing session key")
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_403_FORBIDDEN, detail="Agent missing session key"
|
||||
)
|
||||
gateway = (
|
||||
await session.exec(select(Gateway).where(col(Gateway.main_session_key) == session_key))
|
||||
).first()
|
||||
@@ -675,8 +677,10 @@ async def broadcast_gateway_lead_message(
|
||||
|
||||
gateway, config = await _require_gateway_main(session, agent_ctx.agent)
|
||||
|
||||
statement = select(Board).where(col(Board.gateway_id) == gateway.id).order_by(
|
||||
col(Board.created_at).desc()
|
||||
statement = (
|
||||
select(Board)
|
||||
.where(col(Board.gateway_id) == gateway.id)
|
||||
.order_by(col(Board.created_at).desc())
|
||||
)
|
||||
if payload.board_ids:
|
||||
statement = statement.where(col(Board.id).in_(payload.board_ids))
|
||||
|
||||
400
backend/app/api/board_group_memory.py
Normal file
400
backend/app/api/board_group_memory.py
Normal file
@@ -0,0 +1,400 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import json
|
||||
from collections.abc import AsyncIterator
|
||||
from datetime import datetime, timezone
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException, Query, Request, status
|
||||
from sqlalchemy import func
|
||||
from sqlmodel import col, select
|
||||
from sqlmodel.ext.asyncio.session import AsyncSession
|
||||
from sse_starlette.sse import EventSourceResponse
|
||||
|
||||
from app.api.deps import ActorContext, get_board_or_404, require_admin_auth, require_admin_or_agent
|
||||
from app.core.auth import AuthContext
|
||||
from app.core.config import settings
|
||||
from app.core.time import utcnow
|
||||
from app.db.pagination import paginate
|
||||
from app.db.session import async_session_maker, get_session
|
||||
from app.integrations.openclaw_gateway import GatewayConfig as GatewayClientConfig
|
||||
from app.integrations.openclaw_gateway import OpenClawGatewayError, ensure_session, send_message
|
||||
from app.models.agents import Agent
|
||||
from app.models.board_group_memory import BoardGroupMemory
|
||||
from app.models.board_groups import BoardGroup
|
||||
from app.models.boards import Board
|
||||
from app.models.gateways import Gateway
|
||||
from app.schemas.board_group_memory import BoardGroupMemoryCreate, BoardGroupMemoryRead
|
||||
from app.schemas.pagination import DefaultLimitOffsetPage
|
||||
from app.services.mentions import extract_mentions, matches_agent_mention
|
||||
|
||||
router = APIRouter(tags=["board-group-memory"])
|
||||
|
||||
group_router = APIRouter(prefix="/board-groups/{group_id}/memory", tags=["board-group-memory"])
|
||||
board_router = APIRouter(prefix="/boards/{board_id}/group-memory", tags=["board-group-memory"])
|
||||
|
||||
|
||||
def _parse_since(value: str | None) -> datetime | None:
|
||||
if not value:
|
||||
return None
|
||||
normalized = value.strip()
|
||||
if not normalized:
|
||||
return None
|
||||
normalized = normalized.replace("Z", "+00:00")
|
||||
try:
|
||||
parsed = datetime.fromisoformat(normalized)
|
||||
except ValueError:
|
||||
return None
|
||||
if parsed.tzinfo is not None:
|
||||
return parsed.astimezone(timezone.utc).replace(tzinfo=None)
|
||||
return parsed
|
||||
|
||||
|
||||
def _serialize_memory(memory: BoardGroupMemory) -> dict[str, object]:
|
||||
return BoardGroupMemoryRead.model_validate(memory, from_attributes=True).model_dump(mode="json")
|
||||
|
||||
|
||||
async def _gateway_config(session: AsyncSession, board: Board) -> GatewayClientConfig | None:
|
||||
if board.gateway_id is None:
|
||||
return None
|
||||
gateway = await session.get(Gateway, board.gateway_id)
|
||||
if gateway is None or not gateway.url:
|
||||
return None
|
||||
return GatewayClientConfig(url=gateway.url, token=gateway.token)
|
||||
|
||||
|
||||
async def _send_agent_message(
|
||||
*,
|
||||
session_key: str,
|
||||
config: GatewayClientConfig,
|
||||
agent_name: str,
|
||||
message: str,
|
||||
deliver: bool = False,
|
||||
) -> None:
|
||||
await ensure_session(session_key, config=config, label=agent_name)
|
||||
await send_message(message, session_key=session_key, config=config, deliver=deliver)
|
||||
|
||||
|
||||
async def _fetch_memory_events(
|
||||
session: AsyncSession,
|
||||
board_group_id: UUID,
|
||||
since: datetime,
|
||||
is_chat: bool | None = None,
|
||||
) -> list[BoardGroupMemory]:
|
||||
statement = (
|
||||
select(BoardGroupMemory).where(col(BoardGroupMemory.board_group_id) == board_group_id)
|
||||
# Old/invalid rows (empty/whitespace-only content) can exist; exclude them to
|
||||
# satisfy the NonEmptyStr response schema.
|
||||
.where(func.length(func.trim(col(BoardGroupMemory.content))) > 0)
|
||||
)
|
||||
if is_chat is not None:
|
||||
statement = statement.where(col(BoardGroupMemory.is_chat) == is_chat)
|
||||
statement = statement.where(col(BoardGroupMemory.created_at) >= since).order_by(
|
||||
col(BoardGroupMemory.created_at)
|
||||
)
|
||||
return list(await session.exec(statement))
|
||||
|
||||
|
||||
async def _notify_group_memory_targets(
|
||||
*,
|
||||
session: AsyncSession,
|
||||
group: BoardGroup,
|
||||
memory: BoardGroupMemory,
|
||||
actor: ActorContext,
|
||||
) -> None:
|
||||
if not memory.content:
|
||||
return
|
||||
|
||||
tags = set(memory.tags or [])
|
||||
mentions = extract_mentions(memory.content)
|
||||
is_broadcast = "broadcast" in tags or "all" in mentions
|
||||
|
||||
# Fetch group boards + agents.
|
||||
boards = list(await session.exec(select(Board).where(col(Board.board_group_id) == group.id)))
|
||||
if not boards:
|
||||
return
|
||||
board_by_id = {board.id: board for board in boards}
|
||||
board_ids = list(board_by_id.keys())
|
||||
agents = list(await session.exec(select(Agent).where(col(Agent.board_id).in_(board_ids))))
|
||||
|
||||
targets: dict[str, Agent] = {}
|
||||
for agent in agents:
|
||||
if not agent.openclaw_session_id:
|
||||
continue
|
||||
if actor.actor_type == "agent" and actor.agent and agent.id == actor.agent.id:
|
||||
continue
|
||||
if is_broadcast:
|
||||
targets[str(agent.id)] = agent
|
||||
continue
|
||||
if agent.is_board_lead:
|
||||
targets[str(agent.id)] = agent
|
||||
continue
|
||||
if mentions and matches_agent_mention(agent, mentions):
|
||||
targets[str(agent.id)] = agent
|
||||
|
||||
if not targets:
|
||||
return
|
||||
|
||||
actor_name = "User"
|
||||
if actor.actor_type == "agent" and actor.agent:
|
||||
actor_name = actor.agent.name
|
||||
elif actor.user:
|
||||
actor_name = actor.user.preferred_name or actor.user.name or actor_name
|
||||
|
||||
snippet = memory.content.strip()
|
||||
if len(snippet) > 800:
|
||||
snippet = f"{snippet[:797]}..."
|
||||
|
||||
base_url = settings.base_url or "http://localhost:8000"
|
||||
|
||||
for agent in targets.values():
|
||||
session_key = agent.openclaw_session_id
|
||||
if not session_key:
|
||||
continue
|
||||
board_id = agent.board_id
|
||||
if board_id is None:
|
||||
continue
|
||||
board = board_by_id.get(board_id)
|
||||
if board is None:
|
||||
continue
|
||||
config = await _gateway_config(session, board)
|
||||
if config is None:
|
||||
continue
|
||||
mentioned = matches_agent_mention(agent, mentions)
|
||||
if is_broadcast:
|
||||
header = "GROUP BROADCAST"
|
||||
elif mentioned:
|
||||
header = "GROUP CHAT MENTION"
|
||||
else:
|
||||
header = "GROUP CHAT"
|
||||
message = (
|
||||
f"{header}\n"
|
||||
f"Group: {group.name}\n"
|
||||
f"From: {actor_name}\n\n"
|
||||
f"{snippet}\n\n"
|
||||
"Reply via group chat (shared across linked boards):\n"
|
||||
f"POST {base_url}/api/v1/boards/{board.id}/group-memory\n"
|
||||
'Body: {"content":"...","tags":["chat"]}'
|
||||
)
|
||||
try:
|
||||
await _send_agent_message(
|
||||
session_key=session_key,
|
||||
config=config,
|
||||
agent_name=agent.name,
|
||||
message=message,
|
||||
)
|
||||
except OpenClawGatewayError:
|
||||
continue
|
||||
|
||||
|
||||
@group_router.get("", response_model=DefaultLimitOffsetPage[BoardGroupMemoryRead])
|
||||
async def list_board_group_memory(
|
||||
group_id: UUID,
|
||||
is_chat: bool | None = Query(default=None),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
auth: AuthContext = Depends(require_admin_auth),
|
||||
) -> DefaultLimitOffsetPage[BoardGroupMemoryRead]:
|
||||
group = await session.get(BoardGroup, group_id)
|
||||
if group is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
|
||||
statement = (
|
||||
select(BoardGroupMemory).where(col(BoardGroupMemory.board_group_id) == group_id)
|
||||
# Old/invalid rows (empty/whitespace-only content) can exist; exclude them to
|
||||
# satisfy the NonEmptyStr response schema.
|
||||
.where(func.length(func.trim(col(BoardGroupMemory.content))) > 0)
|
||||
)
|
||||
if is_chat is not None:
|
||||
statement = statement.where(col(BoardGroupMemory.is_chat) == is_chat)
|
||||
statement = statement.order_by(col(BoardGroupMemory.created_at).desc())
|
||||
return await paginate(session, statement)
|
||||
|
||||
|
||||
@group_router.get("/stream")
|
||||
async def stream_board_group_memory(
|
||||
group_id: UUID,
|
||||
request: Request,
|
||||
since: str | None = Query(default=None),
|
||||
is_chat: bool | None = Query(default=None),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
auth: AuthContext = Depends(require_admin_auth),
|
||||
) -> EventSourceResponse:
|
||||
group = await session.get(BoardGroup, group_id)
|
||||
if group is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
|
||||
since_dt = _parse_since(since) or utcnow()
|
||||
last_seen = since_dt
|
||||
|
||||
async def event_generator() -> AsyncIterator[dict[str, str]]:
|
||||
nonlocal last_seen
|
||||
while True:
|
||||
if await request.is_disconnected():
|
||||
break
|
||||
async with async_session_maker() as s:
|
||||
memories = await _fetch_memory_events(
|
||||
s,
|
||||
group_id,
|
||||
last_seen,
|
||||
is_chat=is_chat,
|
||||
)
|
||||
for memory in memories:
|
||||
if memory.created_at > last_seen:
|
||||
last_seen = memory.created_at
|
||||
payload = {"memory": _serialize_memory(memory)}
|
||||
yield {"event": "memory", "data": json.dumps(payload)}
|
||||
await asyncio.sleep(2)
|
||||
|
||||
return EventSourceResponse(event_generator(), ping=15)
|
||||
|
||||
|
||||
@group_router.post("", response_model=BoardGroupMemoryRead)
|
||||
async def create_board_group_memory(
|
||||
group_id: UUID,
|
||||
payload: BoardGroupMemoryCreate,
|
||||
session: AsyncSession = Depends(get_session),
|
||||
auth: AuthContext = Depends(require_admin_auth),
|
||||
) -> BoardGroupMemory:
|
||||
group = await session.get(BoardGroup, group_id)
|
||||
if group is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
|
||||
|
||||
actor = ActorContext(actor_type="user", user=auth.user)
|
||||
tags = set(payload.tags or [])
|
||||
is_chat = "chat" in tags
|
||||
mentions = extract_mentions(payload.content)
|
||||
should_notify = is_chat or "broadcast" in tags or "all" in mentions
|
||||
source = payload.source
|
||||
if should_notify and not source:
|
||||
if actor.actor_type == "agent" and actor.agent:
|
||||
source = actor.agent.name
|
||||
elif actor.user:
|
||||
source = actor.user.preferred_name or actor.user.name or "User"
|
||||
memory = BoardGroupMemory(
|
||||
board_group_id=group_id,
|
||||
content=payload.content,
|
||||
tags=payload.tags,
|
||||
is_chat=is_chat,
|
||||
source=source,
|
||||
)
|
||||
session.add(memory)
|
||||
await session.commit()
|
||||
await session.refresh(memory)
|
||||
if should_notify:
|
||||
await _notify_group_memory_targets(session=session, group=group, memory=memory, actor=actor)
|
||||
return memory
|
||||
|
||||
|
||||
@board_router.get("", response_model=DefaultLimitOffsetPage[BoardGroupMemoryRead])
|
||||
async def list_board_group_memory_for_board(
|
||||
is_chat: bool | None = Query(default=None),
|
||||
board: Board = Depends(get_board_or_404),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
actor: ActorContext = Depends(require_admin_or_agent),
|
||||
) -> DefaultLimitOffsetPage[BoardGroupMemoryRead]:
|
||||
if actor.actor_type == "agent" and actor.agent:
|
||||
if actor.agent.board_id and actor.agent.board_id != board.id:
|
||||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
|
||||
group_id = board.board_group_id
|
||||
if group_id is None:
|
||||
statement = select(BoardGroupMemory).where(col(BoardGroupMemory.id).is_(None))
|
||||
return await paginate(session, statement)
|
||||
|
||||
statement = (
|
||||
select(BoardGroupMemory).where(col(BoardGroupMemory.board_group_id) == group_id)
|
||||
# Old/invalid rows (empty/whitespace-only content) can exist; exclude them to
|
||||
# satisfy the NonEmptyStr response schema.
|
||||
.where(func.length(func.trim(col(BoardGroupMemory.content))) > 0)
|
||||
)
|
||||
if is_chat is not None:
|
||||
statement = statement.where(col(BoardGroupMemory.is_chat) == is_chat)
|
||||
statement = statement.order_by(col(BoardGroupMemory.created_at).desc())
|
||||
return await paginate(session, statement)
|
||||
|
||||
|
||||
@board_router.get("/stream")
|
||||
async def stream_board_group_memory_for_board(
|
||||
request: Request,
|
||||
board: Board = Depends(get_board_or_404),
|
||||
actor: ActorContext = Depends(require_admin_or_agent),
|
||||
since: str | None = Query(default=None),
|
||||
is_chat: bool | None = Query(default=None),
|
||||
) -> EventSourceResponse:
|
||||
if actor.actor_type == "agent" and actor.agent:
|
||||
if actor.agent.board_id and actor.agent.board_id != board.id:
|
||||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
|
||||
group_id = board.board_group_id
|
||||
since_dt = _parse_since(since) or utcnow()
|
||||
last_seen = since_dt
|
||||
|
||||
async def event_generator() -> AsyncIterator[dict[str, str]]:
|
||||
nonlocal last_seen
|
||||
while True:
|
||||
if await request.is_disconnected():
|
||||
break
|
||||
if group_id is None:
|
||||
await asyncio.sleep(2)
|
||||
continue
|
||||
async with async_session_maker() as session:
|
||||
memories = await _fetch_memory_events(
|
||||
session,
|
||||
group_id,
|
||||
last_seen,
|
||||
is_chat=is_chat,
|
||||
)
|
||||
for memory in memories:
|
||||
if memory.created_at > last_seen:
|
||||
last_seen = memory.created_at
|
||||
payload = {"memory": _serialize_memory(memory)}
|
||||
yield {"event": "memory", "data": json.dumps(payload)}
|
||||
await asyncio.sleep(2)
|
||||
|
||||
return EventSourceResponse(event_generator(), ping=15)
|
||||
|
||||
|
||||
@board_router.post("", response_model=BoardGroupMemoryRead)
|
||||
async def create_board_group_memory_for_board(
|
||||
payload: BoardGroupMemoryCreate,
|
||||
board: Board = Depends(get_board_or_404),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
actor: ActorContext = Depends(require_admin_or_agent),
|
||||
) -> BoardGroupMemory:
|
||||
if actor.actor_type == "agent" and actor.agent:
|
||||
if actor.agent.board_id and actor.agent.board_id != board.id:
|
||||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
|
||||
group_id = board.board_group_id
|
||||
if group_id is None:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
||||
detail="Board is not in a board group",
|
||||
)
|
||||
group = await session.get(BoardGroup, group_id)
|
||||
if group is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
|
||||
|
||||
tags = set(payload.tags or [])
|
||||
is_chat = "chat" in tags
|
||||
mentions = extract_mentions(payload.content)
|
||||
should_notify = is_chat or "broadcast" in tags or "all" in mentions
|
||||
source = payload.source
|
||||
if should_notify and not source:
|
||||
if actor.actor_type == "agent" and actor.agent:
|
||||
source = actor.agent.name
|
||||
elif actor.user:
|
||||
source = actor.user.preferred_name or actor.user.name or "User"
|
||||
memory = BoardGroupMemory(
|
||||
board_group_id=group_id,
|
||||
content=payload.content,
|
||||
tags=payload.tags,
|
||||
is_chat=is_chat,
|
||||
source=source,
|
||||
)
|
||||
session.add(memory)
|
||||
await session.commit()
|
||||
await session.refresh(memory)
|
||||
if should_notify:
|
||||
await _notify_group_memory_targets(session=session, group=group, memory=memory, actor=actor)
|
||||
return memory
|
||||
|
||||
|
||||
router.include_router(group_router)
|
||||
router.include_router(board_router)
|
||||
221
backend/app/api/board_groups.py
Normal file
221
backend/app/api/board_groups.py
Normal file
@@ -0,0 +1,221 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from typing import Any, cast
|
||||
from uuid import UUID, uuid4
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException, status
|
||||
from sqlalchemy import delete, func, update
|
||||
from sqlmodel import col, select
|
||||
from sqlmodel.ext.asyncio.session import AsyncSession
|
||||
|
||||
from app.api.deps import ActorContext, require_admin_auth, require_admin_or_agent
|
||||
from app.core.auth import AuthContext
|
||||
from app.core.time import utcnow
|
||||
from app.db import crud
|
||||
from app.db.pagination import paginate
|
||||
from app.db.session import get_session
|
||||
from app.models.agents import Agent
|
||||
from app.models.board_groups import BoardGroup
|
||||
from app.models.boards import Board
|
||||
from app.models.gateways import Gateway
|
||||
from app.schemas.board_group_heartbeat import (
|
||||
BoardGroupHeartbeatApply,
|
||||
BoardGroupHeartbeatApplyResult,
|
||||
)
|
||||
from app.schemas.board_groups import BoardGroupCreate, BoardGroupRead, BoardGroupUpdate
|
||||
from app.schemas.common import OkResponse
|
||||
from app.schemas.pagination import DefaultLimitOffsetPage
|
||||
from app.schemas.view_models import BoardGroupSnapshot
|
||||
from app.services.agent_provisioning import DEFAULT_HEARTBEAT_CONFIG, sync_gateway_agent_heartbeats
|
||||
from app.services.board_group_snapshot import build_group_snapshot
|
||||
|
||||
router = APIRouter(prefix="/board-groups", tags=["board-groups"])
|
||||
|
||||
|
||||
def _slugify(value: str) -> str:
|
||||
slug = re.sub(r"[^a-z0-9]+", "-", value.lower()).strip("-")
|
||||
return slug or uuid4().hex
|
||||
|
||||
|
||||
@router.get("", response_model=DefaultLimitOffsetPage[BoardGroupRead])
|
||||
async def list_board_groups(
|
||||
session: AsyncSession = Depends(get_session),
|
||||
auth: AuthContext = Depends(require_admin_auth),
|
||||
) -> DefaultLimitOffsetPage[BoardGroupRead]:
|
||||
statement = select(BoardGroup).order_by(func.lower(col(BoardGroup.name)).asc())
|
||||
return await paginate(session, statement)
|
||||
|
||||
|
||||
@router.post("", response_model=BoardGroupRead)
|
||||
async def create_board_group(
|
||||
payload: BoardGroupCreate,
|
||||
session: AsyncSession = Depends(get_session),
|
||||
auth: AuthContext = Depends(require_admin_auth),
|
||||
) -> BoardGroup:
|
||||
data = payload.model_dump()
|
||||
if not (data.get("slug") or "").strip():
|
||||
data["slug"] = _slugify(data.get("name") or "")
|
||||
return await crud.create(session, BoardGroup, **data)
|
||||
|
||||
|
||||
@router.get("/{group_id}", response_model=BoardGroupRead)
|
||||
async def get_board_group(
|
||||
group_id: UUID,
|
||||
session: AsyncSession = Depends(get_session),
|
||||
auth: AuthContext = Depends(require_admin_auth),
|
||||
) -> BoardGroup:
|
||||
group = await session.get(BoardGroup, group_id)
|
||||
if group is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
|
||||
return group
|
||||
|
||||
|
||||
@router.get("/{group_id}/snapshot", response_model=BoardGroupSnapshot)
|
||||
async def get_board_group_snapshot(
|
||||
group_id: UUID,
|
||||
include_done: bool = False,
|
||||
per_board_task_limit: int = 5,
|
||||
session: AsyncSession = Depends(get_session),
|
||||
auth: AuthContext = Depends(require_admin_auth),
|
||||
) -> BoardGroupSnapshot:
|
||||
group = await session.get(BoardGroup, group_id)
|
||||
if group is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
|
||||
if per_board_task_limit < 0:
|
||||
raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY)
|
||||
return await build_group_snapshot(
|
||||
session,
|
||||
group=group,
|
||||
exclude_board_id=None,
|
||||
include_done=include_done,
|
||||
per_board_task_limit=per_board_task_limit,
|
||||
)
|
||||
|
||||
|
||||
@router.post("/{group_id}/heartbeat", response_model=BoardGroupHeartbeatApplyResult)
|
||||
async def apply_board_group_heartbeat(
|
||||
group_id: UUID,
|
||||
payload: BoardGroupHeartbeatApply,
|
||||
session: AsyncSession = Depends(get_session),
|
||||
actor: ActorContext = Depends(require_admin_or_agent),
|
||||
) -> BoardGroupHeartbeatApplyResult:
|
||||
group = await session.get(BoardGroup, group_id)
|
||||
if group is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
|
||||
|
||||
if actor.actor_type == "agent":
|
||||
agent = actor.agent
|
||||
if agent is None:
|
||||
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)
|
||||
if agent.board_id is None:
|
||||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
|
||||
if not agent.is_board_lead:
|
||||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
|
||||
board = await session.get(Board, agent.board_id)
|
||||
if board is None or board.board_group_id != group_id:
|
||||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
|
||||
|
||||
boards = list(await session.exec(select(Board).where(col(Board.board_group_id) == group_id)))
|
||||
board_by_id = {board.id: board for board in boards}
|
||||
board_ids = list(board_by_id.keys())
|
||||
if not board_ids:
|
||||
return BoardGroupHeartbeatApplyResult(
|
||||
board_group_id=group_id,
|
||||
requested=payload.model_dump(mode="json"),
|
||||
updated_agent_ids=[],
|
||||
failed_agent_ids=[],
|
||||
)
|
||||
|
||||
agents = list(await session.exec(select(Agent).where(col(Agent.board_id).in_(board_ids))))
|
||||
if not payload.include_board_leads:
|
||||
agents = [agent for agent in agents if not agent.is_board_lead]
|
||||
|
||||
updated_agent_ids: list[UUID] = []
|
||||
for agent in agents:
|
||||
raw = agent.heartbeat_config
|
||||
heartbeat: dict[str, Any] = (
|
||||
cast(dict[str, Any], dict(raw))
|
||||
if isinstance(raw, dict)
|
||||
else cast(dict[str, Any], DEFAULT_HEARTBEAT_CONFIG.copy())
|
||||
)
|
||||
heartbeat["every"] = payload.every
|
||||
if payload.target is not None:
|
||||
heartbeat["target"] = payload.target
|
||||
elif "target" not in heartbeat:
|
||||
heartbeat["target"] = DEFAULT_HEARTBEAT_CONFIG.get("target", "none")
|
||||
agent.heartbeat_config = heartbeat
|
||||
agent.updated_at = utcnow()
|
||||
session.add(agent)
|
||||
updated_agent_ids.append(agent.id)
|
||||
|
||||
await session.commit()
|
||||
|
||||
agents_by_gateway_id: dict[UUID, list[Agent]] = {}
|
||||
for agent in agents:
|
||||
board_id = agent.board_id
|
||||
if board_id is None:
|
||||
continue
|
||||
board = board_by_id.get(board_id)
|
||||
if board is None or board.gateway_id is None:
|
||||
continue
|
||||
agents_by_gateway_id.setdefault(board.gateway_id, []).append(agent)
|
||||
|
||||
failed_agent_ids: list[UUID] = []
|
||||
gateway_ids = list(agents_by_gateway_id.keys())
|
||||
gateways = list(await session.exec(select(Gateway).where(col(Gateway.id).in_(gateway_ids))))
|
||||
gateway_by_id = {gateway.id: gateway for gateway in gateways}
|
||||
for gateway_id, gateway_agents in agents_by_gateway_id.items():
|
||||
gateway = gateway_by_id.get(gateway_id)
|
||||
if gateway is None or not gateway.url or not gateway.workspace_root:
|
||||
failed_agent_ids.extend([agent.id for agent in gateway_agents])
|
||||
continue
|
||||
try:
|
||||
await sync_gateway_agent_heartbeats(gateway, gateway_agents)
|
||||
except Exception:
|
||||
failed_agent_ids.extend([agent.id for agent in gateway_agents])
|
||||
|
||||
return BoardGroupHeartbeatApplyResult(
|
||||
board_group_id=group_id,
|
||||
requested=payload.model_dump(mode="json"),
|
||||
updated_agent_ids=updated_agent_ids,
|
||||
failed_agent_ids=failed_agent_ids,
|
||||
)
|
||||
|
||||
|
||||
@router.patch("/{group_id}", response_model=BoardGroupRead)
|
||||
async def update_board_group(
|
||||
payload: BoardGroupUpdate,
|
||||
group_id: UUID,
|
||||
session: AsyncSession = Depends(get_session),
|
||||
auth: AuthContext = Depends(require_admin_auth),
|
||||
) -> BoardGroup:
|
||||
group = await session.get(BoardGroup, group_id)
|
||||
if group is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
|
||||
updates = payload.model_dump(exclude_unset=True)
|
||||
if "slug" in updates and updates["slug"] is not None and not updates["slug"].strip():
|
||||
updates["slug"] = _slugify(updates.get("name") or group.name)
|
||||
for key, value in updates.items():
|
||||
setattr(group, key, value)
|
||||
group.updated_at = utcnow()
|
||||
return await crud.save(session, group)
|
||||
|
||||
|
||||
@router.delete("/{group_id}", response_model=OkResponse)
|
||||
async def delete_board_group(
|
||||
group_id: UUID,
|
||||
session: AsyncSession = Depends(get_session),
|
||||
auth: AuthContext = Depends(require_admin_auth),
|
||||
) -> OkResponse:
|
||||
group = await session.get(BoardGroup, group_id)
|
||||
if group is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
|
||||
|
||||
# Boards reference groups, so clear the FK first to keep deletes simple.
|
||||
await session.execute(
|
||||
update(Board).where(col(Board.board_group_id) == group_id).values(board_group_id=None)
|
||||
)
|
||||
await session.execute(delete(BoardGroup).where(col(BoardGroup.id) == group_id))
|
||||
await session.commit()
|
||||
return OkResponse()
|
||||
@@ -24,6 +24,7 @@ from app.integrations.openclaw_gateway import (
|
||||
from app.models.activity_events import ActivityEvent
|
||||
from app.models.agents import Agent
|
||||
from app.models.approvals import Approval
|
||||
from app.models.board_groups import BoardGroup
|
||||
from app.models.board_memory import BoardMemory
|
||||
from app.models.board_onboarding import BoardOnboardingSession
|
||||
from app.models.boards import Board
|
||||
@@ -34,7 +35,8 @@ from app.models.tasks import Task
|
||||
from app.schemas.boards import BoardCreate, BoardRead, BoardUpdate
|
||||
from app.schemas.common import OkResponse
|
||||
from app.schemas.pagination import DefaultLimitOffsetPage
|
||||
from app.schemas.view_models import BoardSnapshot
|
||||
from app.schemas.view_models import BoardGroupSnapshot, BoardSnapshot
|
||||
from app.services.board_group_snapshot import build_board_group_snapshot
|
||||
from app.services.board_snapshot import build_board_snapshot
|
||||
|
||||
router = APIRouter(prefix="/boards", tags=["boards"])
|
||||
@@ -68,6 +70,25 @@ async def _require_gateway_for_create(
|
||||
return await _require_gateway(session, payload.gateway_id)
|
||||
|
||||
|
||||
async def _require_board_group(session: AsyncSession, board_group_id: object) -> BoardGroup:
|
||||
group = await crud.get_by_id(session, BoardGroup, board_group_id)
|
||||
if group is None:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
||||
detail="board_group_id is invalid",
|
||||
)
|
||||
return group
|
||||
|
||||
|
||||
async def _require_board_group_for_create(
|
||||
payload: BoardCreate,
|
||||
session: AsyncSession = Depends(get_session),
|
||||
) -> BoardGroup | None:
|
||||
if payload.board_group_id is None:
|
||||
return None
|
||||
return await _require_board_group(session, payload.board_group_id)
|
||||
|
||||
|
||||
async def _apply_board_update(
|
||||
*,
|
||||
payload: BoardUpdate,
|
||||
@@ -77,6 +98,8 @@ async def _apply_board_update(
|
||||
updates = payload.model_dump(exclude_unset=True)
|
||||
if "gateway_id" in updates:
|
||||
await _require_gateway(session, updates["gateway_id"])
|
||||
if "board_group_id" in updates and updates["board_group_id"] is not None:
|
||||
await _require_board_group(session, updates["board_group_id"])
|
||||
for key, value in updates.items():
|
||||
setattr(board, key, value)
|
||||
if updates.get("board_type") == "goal":
|
||||
@@ -157,12 +180,15 @@ async def _cleanup_agent_on_gateway(
|
||||
@router.get("", response_model=DefaultLimitOffsetPage[BoardRead])
|
||||
async def list_boards(
|
||||
gateway_id: UUID | None = Query(default=None),
|
||||
board_group_id: UUID | None = Query(default=None),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
actor: ActorContext = Depends(require_admin_or_agent),
|
||||
) -> DefaultLimitOffsetPage[BoardRead]:
|
||||
statement = select(Board)
|
||||
if gateway_id is not None:
|
||||
statement = statement.where(col(Board.gateway_id) == gateway_id)
|
||||
if board_group_id is not None:
|
||||
statement = statement.where(col(Board.board_group_id) == board_group_id)
|
||||
statement = statement.order_by(func.lower(col(Board.name)).asc(), col(Board.created_at).desc())
|
||||
return await paginate(session, statement)
|
||||
|
||||
@@ -171,6 +197,7 @@ async def list_boards(
|
||||
async def create_board(
|
||||
payload: BoardCreate,
|
||||
_gateway: Gateway = Depends(_require_gateway_for_create),
|
||||
_board_group: BoardGroup | None = Depends(_require_board_group_for_create),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
auth: AuthContext = Depends(require_admin_auth),
|
||||
) -> Board:
|
||||
@@ -197,6 +224,27 @@ async def get_board_snapshot(
|
||||
return await build_board_snapshot(session, board)
|
||||
|
||||
|
||||
@router.get("/{board_id}/group-snapshot", response_model=BoardGroupSnapshot)
|
||||
async def get_board_group_snapshot(
|
||||
include_self: bool = Query(default=False),
|
||||
include_done: bool = Query(default=False),
|
||||
per_board_task_limit: int = Query(default=5, ge=0, le=100),
|
||||
board: Board = Depends(get_board_or_404),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
actor: ActorContext = Depends(require_admin_or_agent),
|
||||
) -> BoardGroupSnapshot:
|
||||
if actor.actor_type == "agent" and actor.agent:
|
||||
if actor.agent.board_id and actor.agent.board_id != board.id:
|
||||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
|
||||
return await build_board_group_snapshot(
|
||||
session,
|
||||
board=board,
|
||||
include_self=include_self,
|
||||
include_done=include_done,
|
||||
per_board_task_limit=per_board_task_limit,
|
||||
)
|
||||
|
||||
|
||||
@router.patch("/{board_id}", response_model=BoardRead)
|
||||
async def update_board(
|
||||
payload: BoardUpdate,
|
||||
|
||||
Reference in New Issue
Block a user