"""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)