Refactor backend API and introduce cron scheduling support

- Removed the `teams` endpoint and associated logic, simplifying the agent management API.
- Updated agent creation and listing to support grouping without team context.
- Added a new `CronScheduler` service to handle scheduled events based on subscription cron expressions.
- Enhanced event handling with manual event triggering and event catalog retrieval.
- Updated FastAPI application description and integrated new routers for events and subscriptions.
- Modified requirements to include `croniter` for cron expression parsing.
- Improved frontend navigation and components to accommodate new event and agent management features.

Author: SUGE2016

backend/app/api/agents.py

@@ -1,42 +1,49 @@
-from fastapi import APIRouter, Depends, HTTPException
+import uuid
+from pathlib import Path
+
+from fastapi import APIRouter, Depends, HTTPException, Query
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.database import get_db
-from app.models.tables import Agent, Team
+from app.config import settings
+from app.models.tables import Agent
 from app.models.schemas import AgentCreate, AgentUpdate, AgentOut
 
-router = APIRouter(prefix="/teams/{team_id}/agents", tags=["agents"])
-
-
-async def _ensure_team(team_id: str, db: AsyncSession) -> Team:
-    team = await db.get(Team, team_id)
-    if not team:
-        raise HTTPException(404, "Team not found")
-    return team
+router = APIRouter(prefix="/agents", tags=["agents"])
 
 
 @router.get("", response_model=list[AgentOut])
-async def list_agents(team_id: str, db: AsyncSession = Depends(get_db)):
-    await _ensure_team(team_id, db)
-    result = await db.execute(
-        select(Agent).where(Agent.team_id == team_id).order_by(Agent.created_at)
-    )
+async def list_agents(
+    group: str | None = Query(None),
+    db: AsyncSession = Depends(get_db),
+):
+    query = select(Agent).order_by(Agent.created_at)
+    if group:
+        query = query.where(Agent.group == group)
+    result = await db.execute(query)
     return result.scalars().all()
 
 
 @router.post("", response_model=AgentOut, status_code=201)
-async def create_agent(team_id: str, body: AgentCreate, db: AsyncSession = Depends(get_db)):
-    await _ensure_team(team_id, db)
+async def create_agent(body: AgentCreate, db: AsyncSession = Depends(get_db)):
+    agent_id = uuid.uuid4().hex[:12]
+    workspace = body.workspace_path.strip()
+    if not workspace:
+        workspace = str(settings.workspace_root / agent_id)
+    Path(workspace).mkdir(parents=True, exist_ok=True)
+
     agent = Agent(
-        team_id=team_id,
+        id=agent_id,
         name=body.name,
+        group=body.group,
         role=body.role,
         description=body.description,
         model=body.model,
         system_prompt=body.system_prompt,
         skills=body.skills,
         mcp_config_path=body.mcp_config_path,
+        workspace_path=workspace,
     )
     db.add(agent)
     await db.commit()
@@ -45,19 +52,17 @@ async def create_agent(team_id: str, body: AgentCreate, db: AsyncSession = Depen
 
 
 @router.get("/{agent_id}", response_model=AgentOut)
-async def get_agent(team_id: str, agent_id: str, db: AsyncSession = Depends(get_db)):
-    await _ensure_team(team_id, db)
+async def get_agent(agent_id: str, db: AsyncSession = Depends(get_db)):
     agent = await db.get(Agent, agent_id)
-    if not agent or agent.team_id != team_id:
+    if not agent:
         raise HTTPException(404, "Agent not found")
     return agent
 
 
 @router.put("/{agent_id}", response_model=AgentOut)
-async def update_agent(team_id: str, agent_id: str, body: AgentUpdate, db: AsyncSession = Depends(get_db)):
-    await _ensure_team(team_id, db)
+async def update_agent(agent_id: str, body: AgentUpdate, db: AsyncSession = Depends(get_db)):
     agent = await db.get(Agent, agent_id)
-    if not agent or agent.team_id != team_id:
+    if not agent:
         raise HTTPException(404, "Agent not found")
     for field, value in body.model_dump(exclude_unset=True).items():
         setattr(agent, field, value)
@@ -67,10 +72,9 @@ async def update_agent(team_id: str, agent_id: str, body: AgentUpdate, db: Async
 
 
 @router.delete("/{agent_id}", status_code=204)
-async def delete_agent(team_id: str, agent_id: str, db: AsyncSession = Depends(get_db)):
-    await _ensure_team(team_id, db)
+async def delete_agent(agent_id: str, db: AsyncSession = Depends(get_db)):
     agent = await db.get(Agent, agent_id)
-    if not agent or agent.team_id != team_id:
+    if not agent:
         raise HTTPException(404, "Agent not found")
     await db.delete(agent)
     await db.commit()

backend/app/api/events.py

@@ -1,5 +1,6 @@
-"""Event Gateway API: webhook 接收 + 事件日志查询。"""
+"""Event Gateway API: webhook 接收 + 手动触发 + 事件目录 + 事件日志查询。"""
 
+from pydantic import BaseModel
 from fastapi import APIRouter, Depends, Request, HTTPException, Query
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -8,11 +9,22 @@
 from app.db.database import get_db
 from app.models.tables import Subscription, EventLog
 from app.models.schemas import EventLogOut
-from app.services.event_normalizer import detect_and_normalize
+from app.services.event_normalizer import (
+    detect_and_normalize,
+    get_event_catalog,
+    _make_event,
+)
 from app.services.event_router import match_subscriptions
 from app.services.event_dispatcher import dispatch_event
 
-router = APIRouter(prefix="/api/events", tags=["events"])
+router = APIRouter(prefix="/events", tags=["events"])
+
+
+class ManualEventBody(BaseModel):
+    event_type: str
+    source: str = "manual/test"
+    subject: str = ""
+    data: dict = {}
 
 
 @router.post("/webhook/{source}")
@@ -53,6 +65,43 @@ async def receive_webhook(
     }
 
 
+@router.get("/catalog")
+async def event_catalog():
+    """返回系统支持的所有事件源和事件类型。"""
+    return get_event_catalog()
+
+
+@router.post("/manual")
+async def trigger_manual_event(
+    body: ManualEventBody,
+    db: AsyncSession = Depends(get_db),
+):
+    """手动触发一个事件，用于测试/模拟。"""
+    event = _make_event(
+        source=body.source,
+        event_type=body.event_type,
+        subject=body.subject,
+        data=body.data,
+    )
+
+    subs_result = await db.execute(
+        select(Subscription).where(Subscription.enabled == True)  # noqa: E712
+    )
+    subscriptions = list(subs_result.scalars().all())
+
+    matched_ids = match_subscriptions(event, subscriptions)
+
+    event_log = await dispatch_event(event, matched_ids, db)
+
+    return {
+        "event_id": event_log.id,
+        "type": event.get("type"),
+        "source": event.get("source"),
+        "matched_agents": matched_ids,
+        "status": event_log.status,
+    }
+
+
 @router.get("", response_model=list[EventLogOut])
 async def list_events(
     source: str | None = Query(None),

backend/app/api/runs.py

@@ -8,7 +8,7 @@
 from app.models.tables import Agent, Subscription
 from app.models.schemas import SubscriptionCreate, SubscriptionUpdate, SubscriptionOut
 
-router = APIRouter(prefix="/api/agents/{agent_id}/subscriptions", tags=["subscriptions"])
+router = APIRouter(prefix="/agents/{agent_id}/subscriptions", tags=["subscriptions"])
 
 
 async def _ensure_agent(agent_id: str, db: AsyncSession) -> Agent: