Files

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)