132 lines
3.9 KiB
Python
132 lines
3.9 KiB
Python
from fastapi import APIRouter, HTTPException, WebSocket, WebSocketDisconnect
|
|
from app.models.session import CreateSessionRequest, SessionType
|
|
from app.services.session_manager import session_manager
|
|
from app.services.scheduler import scheduler_service, ScheduleTask
|
|
from app.services.opencode_client import opencode_client
|
|
from app.services.history import history_service
|
|
from app.services.persistent_session import persistent_session_manager
|
|
from app.services.websocket_manager import ws_manager
|
|
|
|
|
|
router = APIRouter(prefix="/api/xcclaw", tags=["xcclaw"])
|
|
|
|
|
|
@router.get("/health")
|
|
async def health_check():
|
|
try:
|
|
opencode_status = await opencode_client.health_check()
|
|
return {"status": "ok", "opencode": opencode_status}
|
|
except Exception as e:
|
|
return {"status": "error", "message": str(e)}
|
|
|
|
|
|
@router.websocket("/ws")
|
|
async def websocket_endpoint(websocket: WebSocket):
|
|
await ws_manager.connect(websocket)
|
|
try:
|
|
while True:
|
|
await websocket.receive_text()
|
|
except WebSocketDisconnect:
|
|
ws_manager.disconnect(websocket)
|
|
|
|
|
|
@router.post("/task")
|
|
async def create_task(request: CreateSessionRequest):
|
|
task = await session_manager.create_task(request)
|
|
return task
|
|
|
|
|
|
@router.post("/task/{task_id}/execute")
|
|
async def execute_task(task_id: str):
|
|
result = await session_manager.execute_task(task_id)
|
|
return result
|
|
|
|
|
|
@router.post("/task/{task_id}/execute_async")
|
|
async def execute_task_async(task_id: str):
|
|
task = await session_manager.get_task(task_id)
|
|
if not task:
|
|
raise HTTPException(status_code=404, detail="Task not found")
|
|
|
|
await session_manager.execute_task_async(task_id)
|
|
return {"status": "started", "task_id": task_id}
|
|
|
|
|
|
@router.post("/task/{task_id}/abort")
|
|
async def abort_task(task_id: str):
|
|
result = await session_manager.abort_task(task_id)
|
|
return {"aborted": result}
|
|
|
|
|
|
@router.get("/task/{task_id}")
|
|
async def get_task(task_id: str):
|
|
task = await session_manager.get_task(task_id)
|
|
if not task:
|
|
raise HTTPException(status_code=404, detail="Task not found")
|
|
return task
|
|
|
|
|
|
@router.get("/task")
|
|
async def list_tasks():
|
|
return await session_manager.list_tasks()
|
|
|
|
|
|
@router.post("/schedule")
|
|
async def create_schedule(task: ScheduleTask):
|
|
return await scheduler_service.add_schedule(task)
|
|
|
|
|
|
@router.get("/schedule")
|
|
async def list_schedules():
|
|
return await scheduler_service.list_schedules()
|
|
|
|
|
|
@router.delete("/schedule/{schedule_id}")
|
|
async def delete_schedule(schedule_id: str):
|
|
result = await scheduler_service.remove_schedule(schedule_id)
|
|
if not result:
|
|
raise HTTPException(status_code=404, detail="Schedule not found")
|
|
return {"deleted": True}
|
|
|
|
|
|
@router.get("/history")
|
|
async def get_history(limit: int | None = None):
|
|
return history_service.get_history(limit)
|
|
|
|
|
|
@router.delete("/history")
|
|
async def clear_history():
|
|
history_service.clear_history()
|
|
return {"cleared": True}
|
|
|
|
|
|
@router.post("/persistent")
|
|
async def create_persistent_session(name: str | None = None):
|
|
session = await persistent_session_manager.create_session(name)
|
|
return session
|
|
|
|
|
|
@router.get("/persistent")
|
|
async def list_persistent_sessions():
|
|
return persistent_session_manager.list_sessions()
|
|
|
|
|
|
@router.delete("/persistent/{session_id}")
|
|
async def delete_persistent_session(session_id: str):
|
|
result = await persistent_session_manager.delete_session(session_id)
|
|
if not result:
|
|
raise HTTPException(status_code=404, detail="Persistent session not found")
|
|
return {"deleted": True}
|
|
|
|
|
|
@router.post("/persistent/{session_id}/message")
|
|
async def send_persistent_message(session_id: str, text: str):
|
|
result = await persistent_session_manager.send_message(session_id, text)
|
|
return result
|
|
|
|
|
|
@router.post("/persistent/{session_id}/message_async")
|
|
async def send_persistent_message_async(session_id: str, text: str):
|
|
await persistent_session_manager.send_message_async(session_id, text)
|
|
return {"status": "sent", "session_id": session_id}
|