@agentunion/kite 1.0.7 → 1.3.0

package/extensions/services/web/routes/routes_devlog.py

@@ -0,0 +1,99 @@
+"""Routes for development log management."""
+
+from __future__ import annotations
+
+import logging
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+from routes.schemas import (
+    DevLogCreate,
+    DevLogRecord,
+    DevLogUpdate,
+    PaginatedResponse,
+)
+from vendor.storage import store
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["devlog"])
+
+
+@router.get("/devlog", response_model=PaginatedResponse)
+async def list_devlog(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=200),
+    status: str | None = Query(None),
+):
+    items, total = await store.list_devlog(page=page, page_size=page_size, status=status)
+    return PaginatedResponse(items=items, total=total, page=page, page_size=page_size)
+
+
+@router.post("/devlog", response_model=DevLogRecord)
+async def add_devlog(req: DevLogCreate):
+    data = req.model_dump(exclude_none=True)
+    record = await store.add_devlog(data)
+    return DevLogRecord(**record)
+
+
+# --- Archive routes (must be before {record_id} to avoid path conflicts) ---
+
+class ArchiveRequest(BaseModel):
+    cutoff: str | None = None  # ISO-8601 datetime string
+
+
+@router.post("/devlog/archive")
+async def archive_devlog(req: ArchiveRequest | None = None):
+    cutoff = req.cutoff if req else None
+    result = await store.archive_devlog(cutoff_iso=cutoff)
+    return result
+
+
+@router.get("/devlog/archives")
+async def list_devlog_archives():
+    dates = await store.list_devlog_archives()
+    return {"dates": dates}
+
+
+@router.get("/devlog/archive/last-cutoff")
+async def get_last_archive_cutoff():
+    cutoff = await store.get_last_archive_cutoff()
+    return {"last_cutoff": cutoff}
+
+
+@router.get("/devlog/archives/{date_str}")
+async def read_devlog_archive(date_str: str):
+    records = await store.read_devlog_archive(date_str)
+    return {"date": date_str, "records": records}
+
+
+# --- Single record routes ---
+
+@router.get("/devlog/{record_id}", response_model=DevLogRecord)
+async def get_devlog(record_id: str):
+    record = await store.get_devlog(record_id)
+    if record is None:
+        raise HTTPException(status_code=404, detail="Dev log not found")
+    return DevLogRecord(**record)
+
+
+@router.put("/devlog/{record_id}", response_model=DevLogRecord)
+async def update_devlog(record_id: str, updates: DevLogUpdate):
+    existing = await store.get_devlog(record_id)
+    if existing is None:
+        raise HTTPException(status_code=404, detail="Dev log not found")
+    update_data = updates.model_dump(exclude_none=True)
+    if not update_data:
+        raise HTTPException(status_code=400, detail="No fields to update")
+    await store.update_devlog(record_id, update_data)
+    updated = await store.get_devlog(record_id)
+    return DevLogRecord(**updated)
+
+
+@router.delete("/devlog/{record_id}")
+async def delete_devlog(record_id: str):
+    success = await store.delete_devlog(record_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Dev log not found")
+    return {"status": "deleted", "id": record_id}

package/extensions/services/web/routes/routes_phone.py

@@ -0,0 +1,81 @@
+"""Routes for phone / Bluetooth management."""
+
+from __future__ import annotations
+
+import logging
+
+from fastapi import APIRouter, HTTPException, Request
+
+from routes.schemas import PhoneStatus
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["phone"])
+
+
+@router.get("/phone/status", response_model=PhoneStatus)
+async def phone_status(request: Request):
+    """Return the current Bluetooth / phone connection status."""
+    bt: object = request.app.state.bt_manager
+    try:
+        status = bt.get_status()  # sync method
+        return PhoneStatus(
+            bluetooth_connected=status.get("connected", False),
+            device_name=status.get("device_name"),
+            device_address=status.get("device_address"),
+            battery_level=status.get("battery_level"),
+            signal_strength=status.get("signal_strength"),
+            operator=status.get("operator_name"),
+            in_call=status.get("in_call", False),
+        )
+    except Exception as exc:
+        logger.exception("Failed to get phone status")
+        raise HTTPException(status_code=500, detail=str(exc))
+
+
+@router.get("/phone/devices")
+async def list_devices(request: Request):
+    """Scan for nearby Bluetooth devices."""
+    bt = request.app.state.bt_manager
+    try:
+        devices = await bt.scan_devices()
+        return {"devices": devices}
+    except Exception as exc:
+        logger.exception("Bluetooth scan failed")
+        raise HTTPException(status_code=500, detail=str(exc))
+
+
+@router.post("/phone/pair")
+async def pair_device(request: Request, address: str):
+    """Pair with a Bluetooth device by its MAC address."""
+    bt = request.app.state.bt_manager
+    try:
+        result = await bt.pair_device(address)
+        return {"status": "paired", "address": address, "detail": result}
+    except Exception as exc:
+        logger.exception("Bluetooth pairing failed for %s", address)
+        raise HTTPException(status_code=500, detail=str(exc))
+
+
+@router.post("/phone/connect")
+async def connect_device(request: Request, address: str):
+    """Connect to an already-paired Bluetooth device."""
+    bt = request.app.state.bt_manager
+    try:
+        result = await bt.connect(address)
+        return {"status": "connected", "address": address, "detail": result}
+    except Exception as exc:
+        logger.exception("Bluetooth connect failed for %s", address)
+        raise HTTPException(status_code=500, detail=str(exc))
+
+
+@router.post("/phone/disconnect")
+async def disconnect_device(request: Request):
+    """Disconnect the current Bluetooth device."""
+    bt = request.app.state.bt_manager
+    try:
+        result = await bt.disconnect()
+        return {"status": "disconnected", "detail": result}
+    except Exception as exc:
+        logger.exception("Bluetooth disconnect failed")
+        raise HTTPException(status_code=500, detail=str(exc))

package/extensions/services/web/routes/routes_sms.py

@@ -0,0 +1,48 @@
+"""Routes for SMS send / receive management."""
+
+from __future__ import annotations
+
+import logging
+
+from fastapi import APIRouter, HTTPException, Query, Request
+
+from routes.schemas import PaginatedResponse, SMSRecord, SMSRequest
+from vendor.storage import store
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["sms"])
+
+
+@router.post("/sms", response_model=SMSRecord)
+async def send_sms(request_body: SMSRequest, request: Request):
+    """Send an SMS message via the connected phone."""
+    bt = request.app.state.bt_manager
+    try:
+        await bt.send_sms(request_body.phone_number, request_body.content)
+    except Exception as exc:
+        logger.exception("Failed to send SMS to %s", request_body.phone_number)
+        raise HTTPException(status_code=500, detail=f"Failed to send SMS: {exc}")
+
+    record = await store.save_sms({
+        "phone_number": request_body.phone_number,
+        "content": request_body.content,
+        "direction": "outgoing",
+        "status": "sent",
+    })
+    return SMSRecord(**record)
+
+
+@router.get("/sms", response_model=PaginatedResponse)
+async def list_sms(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    phone_number: str | None = Query(None),
+):
+    """List SMS messages with optional phone-number filter and pagination."""
+    items, total = await store.list_sms(
+        page=page,
+        page_size=page_size,
+        phone_number=phone_number,
+    )
+    return PaginatedResponse(items=items, total=total, page=page, page_size=page_size)

package/extensions/services/web/routes/routes_stats.py

@@ -0,0 +1,17 @@
+"""Routes for aggregate statistics."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter
+
+from routes.schemas import StatsResponse
+from vendor.storage import store
+
+router = APIRouter(tags=["stats"])
+
+
+@router.get("/stats", response_model=StatsResponse)
+async def get_stats():
+    """Return aggregate statistics across calls, SMS, and contacts."""
+    data = await store.get_stats()
+    return StatsResponse(**data)