225 lines
7.2 KiB
Python
225 lines
7.2 KiB
Python
"""MCP OpenWearables Server — read-only Abfrage der eigenen Wearable-Daten.
|
|
|
|
User-Trennung ueber das gemeinsame OAuth (common.get_current_user()):
|
|
- mycroft sendet MCP_BEARER (client_id=stefan) -> OpenWearables-User Stefan
|
|
- jarvis sendet MCP_BEARER (client_id=kati) -> OpenWearables-User Kati
|
|
|
|
Der OpenWearables-API-Key ist GLOBAL (nicht pro User gescoped). Die eigentliche
|
|
User-Trennung passiert HIER: die OpenWearables-User-ID wird IMMER aus dem Login
|
|
des Clients bestimmt und nie aus einem Tool-Argument uebernommen. Dadurch kann
|
|
ein Agent die Daten des anderen nicht ansprechen.
|
|
"""
|
|
|
|
import json
|
|
import os
|
|
import sys
|
|
from contextlib import AsyncExitStack, asynccontextmanager
|
|
from datetime import date, timedelta
|
|
|
|
import httpx
|
|
from mcp.server.fastmcp import FastMCP
|
|
from starlette.applications import Starlette
|
|
from starlette.routing import Mount
|
|
|
|
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
|
|
from common import OAUTH_ROUTES, BearerAuthMiddleware, get_current_user
|
|
|
|
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
|
|
with open(os.path.join(BASE_DIR, "config.json")) as f:
|
|
_cfg = json.load(f)
|
|
|
|
API_URL = _cfg["open_wearables_api_url"].rstrip("/")
|
|
API_KEY = _cfg["open_wearables_api_key"]
|
|
# Map local/openclaw user -> OpenWearables user UUID.
|
|
USER_ID_MAP = _cfg["user_id_map"]
|
|
|
|
|
|
class OpenWearablesError(RuntimeError):
|
|
pass
|
|
|
|
|
|
def _require_user() -> str:
|
|
"""OpenWearables-User-ID des aktuell eingeloggten Clients."""
|
|
owner = get_current_user()
|
|
uid = USER_ID_MAP.get(owner or "")
|
|
if not uid:
|
|
raise OpenWearablesError(
|
|
"Zugriff verweigert: dieser Account hat keinen OpenWearables-User"
|
|
)
|
|
return uid
|
|
|
|
|
|
def _range(start: str, end: str) -> tuple[str, str]:
|
|
if start and end:
|
|
return start, end
|
|
e = date.today()
|
|
s = e - timedelta(days=14)
|
|
return s.isoformat(), e.isoformat()
|
|
|
|
|
|
def _request(path: str, params: dict | None = None) -> dict:
|
|
"""Blockierender API-Aufruf (MCP-Tools sind sync)."""
|
|
url = f"{API_URL}{path}"
|
|
try:
|
|
with httpx.Client(timeout=30) as client:
|
|
r = client.get(
|
|
url,
|
|
params=params,
|
|
headers={
|
|
"X-Open-Wearables-API-Key": API_KEY,
|
|
"Content-Type": "application/json",
|
|
},
|
|
)
|
|
if r.status_code == 401:
|
|
raise OpenWearablesError("ungueltiger OpenWearables-API-Key")
|
|
if r.status_code == 404:
|
|
raise OpenWearablesError(f"nicht gefunden: {path}")
|
|
r.raise_for_status()
|
|
return r.json()
|
|
except OpenWearablesError:
|
|
raise
|
|
except httpx.HTTPError as ex:
|
|
raise OpenWearablesError(f"OpenWearables-API-Fehler: {ex}") from ex
|
|
|
|
|
|
mcp = FastMCP(
|
|
"OpenWearables",
|
|
stateless_http=True,
|
|
transport_security={"enable_dns_rebinding_protection": False},
|
|
)
|
|
|
|
|
|
@mcp.tool()
|
|
def get_users() -> dict:
|
|
"""Discover OpenWearables users accessible to the current client.
|
|
|
|
Liefert NUR den eigenen Eintrag des eingeloggten Clients (stefan oder kati),
|
|
nie fremde User. Rueckgabe enthaelt OpenWearables user_id, email und Sync-Status.
|
|
"""
|
|
owner = get_current_user()
|
|
if not owner:
|
|
return {"error": "not authenticated"}
|
|
uid = USER_ID_MAP.get(owner)
|
|
if not uid:
|
|
return {"error": f"account '{owner}' hat keinen OpenWearables-User"}
|
|
try:
|
|
u = _request(f"/api/v1/users/{uid}")
|
|
except OpenWearablesError as e:
|
|
return {"error": str(e)}
|
|
return {
|
|
"users": [{
|
|
"id": u.get("id"),
|
|
"first_name": u.get("first_name"),
|
|
"last_name": u.get("last_name"),
|
|
"email": u.get("email"),
|
|
"external_user_id": u.get("external_user_id"),
|
|
"last_synced_at": u.get("last_synced_at"),
|
|
"last_synced_provider": u.get("last_synced_provider"),
|
|
"has_active_connection": u.get("has_active_connection"),
|
|
}],
|
|
"total": 1,
|
|
}
|
|
|
|
|
|
@mcp.tool()
|
|
def get_sleep_summary(start_date: str = "", end_date: str = "") -> dict:
|
|
"""Tages-Sleep-Summaries innerhalb eines Datumsbereichs (YYYY-MM-DD).
|
|
|
|
Liefert pro Nacht start_datetime, end_datetime und duration. Ohne Datums-
|
|
angabe werden die letzten 14 Tage genommen.
|
|
"""
|
|
try:
|
|
s, e = _range(start_date, end_date)
|
|
return _request(
|
|
f"/api/v1/users/{_require_user()}/summaries/sleep",
|
|
{"start_date": s, "end_date": e, "limit": 100},
|
|
)
|
|
except OpenWearablesError as err:
|
|
return _err(err)
|
|
|
|
|
|
@mcp.tool()
|
|
def get_activity_summary(start_date: str = "", end_date: str = "") -> dict:
|
|
"""Tages-Aktivitaets-Summaries innerhalb eines Datumsbereichs.
|
|
|
|
Werte u.a.: steps, calories, heart rate, distance, Intensity Minutes.
|
|
"""
|
|
try:
|
|
s, e = _range(start_date, end_date)
|
|
return _request(
|
|
f"/api/v1/users/{_require_user()}/summaries/activity",
|
|
{"start_date": s, "end_date": e, "limit": 100},
|
|
)
|
|
except OpenWearablesError as ex:
|
|
return {"error": str(ex)}
|
|
|
|
|
|
@mcp.tool()
|
|
def get_workout_events(start_date: str = "", end_date: str = "") -> dict:
|
|
"""Workout-Sessions innerhalb eines Datumsbereichs (YYYY-MM-DD).
|
|
|
|
Liefert sessions mit typ, duration, distance, calories. Default letzte 14 Tage.
|
|
"""
|
|
try:
|
|
s, e = _range(start_date, end_date)
|
|
return _request(
|
|
f"/api/v1/users/{_require_user()}/events/workouts",
|
|
{"start_date": s, "end_date": e, "limit": 100},
|
|
)
|
|
except OpenWearablesError as ex:
|
|
return {"error": str(ex)}
|
|
|
|
|
|
@mcp.tool()
|
|
def get_timeseries(
|
|
types: list[str],
|
|
start_time: str = "",
|
|
end_time: str = "",
|
|
resolution: str = "raw",
|
|
) -> dict:
|
|
"""Granulare Zeitreihen-Samples (heart_rate, weight, SpO2, HRV, blood_glucose, ...).
|
|
|
|
Args:
|
|
types: Liste an series type codes, z.B. ["heart_rate","oxygen_saturation"]
|
|
start_time/end_time: ISO-8601; ohne Angabe werden die letzten 24h genommen
|
|
resolution: raw|1min|5min|15min|1hour
|
|
"""
|
|
if not (start_time and end_time):
|
|
end = date.today()
|
|
start = end - timedelta(days=1)
|
|
start_time = f"{start.isoformat()}T00:00:00Z"
|
|
end_time = f"{end.isoformat()}T23:59:59Z"
|
|
joined = ",".join(types) if isinstance(types, list) else str(types)
|
|
try:
|
|
return _request(
|
|
f"/api/v1/users/{_require_user()}/timeseries",
|
|
{
|
|
"start_time": start_time,
|
|
"end_time": end_time,
|
|
"types": joined,
|
|
"resolution": resolution,
|
|
"limit": 100,
|
|
},
|
|
)
|
|
except OpenWearablesError as ex:
|
|
return {"error": str(ex)}
|
|
|
|
|
|
def create_app():
|
|
mcp_app = mcp.streamable_http_app()
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app):
|
|
async with AsyncExitStack() as stack:
|
|
await stack.enter_async_context(mcp_app.router.lifespan_context(mcp_app))
|
|
yield
|
|
|
|
routes = list(OAUTH_ROUTES) + [Mount("/", app=mcp_app)]
|
|
app = Starlette(routes=routes, lifespan=lifespan)
|
|
app.add_middleware(BearerAuthMiddleware)
|
|
return app
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import uvicorn
|
|
uvicorn.run(create_app(), host="0.0.0.0", port=5105) |