getbased-mcp 0.2.2__tar.gz → 0.2.4__tar.gz

{getbased_mcp-0.2.2 → getbased_mcp-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: getbased-mcp
-Version: 0.2.2
+Version: 0.2.4
 Summary: MCP server for querying blood work data and knowledge base from getbased
 License-Expression: GPL-3.0-only
 Requires-Python: >=3.10

{getbased_mcp-0.2.2 → getbased_mcp-0.2.4}/getbased_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: getbased-mcp
-Version: 0.2.2
+Version: 0.2.4
 Summary: MCP server for querying blood work data and knowledge base from getbased
 License-Expression: GPL-3.0-only
 Requires-Python: >=3.10

{getbased_mcp-0.2.2 → getbased_mcp-0.2.4}/getbased_mcp.egg-info/SOURCES.txt

@@ -8,4 +8,5 @@ getbased_mcp.egg-info/dependency_links.txt
 getbased_mcp.egg-info/entry_points.txt
 getbased_mcp.egg-info/requires.txt
 getbased_mcp.egg-info/top_level.txt
+tests/test_env_loader.py
 tests/test_tools.py

{getbased_mcp-0.2.2 → getbased_mcp-0.2.4}/getbased_mcp.py

@@ -21,6 +21,42 @@ import time
 import httpx
 from mcp.server.fastmcp import FastMCP
 
+
+def _maybe_load_user_env() -> None:
+    """Opt-in: load $XDG_CONFIG_HOME/getbased/env into os.environ.
+
+    Guarded by GETBASED_STACK_MANAGED=1 so existing deployments that wire env
+    explicitly (Hermes via ~/.hermes/config.yaml, hand-rolled setups) are
+    untouched. Uses setdefault — an explicit env var always wins over the file.
+    Silent on a missing file; malformed lines skipped without crashing.
+    Escape hatch: GETBASED_NO_ENV_FILE=1 disables even when managed.
+    """
+    if os.environ.get("GETBASED_STACK_MANAGED") != "1":
+        return
+    if os.environ.get("GETBASED_NO_ENV_FILE") == "1":
+        return
+    xdg = os.environ.get("XDG_CONFIG_HOME") or os.path.expanduser("~/.config")
+    path = os.path.join(xdg, "getbased", "env")
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            lines = fh.readlines()
+    except OSError:
+        return
+    for raw in lines:
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, val = line.partition("=")
+        key = key.strip()
+        val = val.strip()
+        if len(val) >= 2 and val[0] == val[-1] and val[0] in ("'", '"'):
+            val = val[1:-1]
+        if key:
+            os.environ.setdefault(key, val)
+
+
+_maybe_load_user_env()
+
 log = logging.getLogger("getbased_mcp")
 
 mcp = FastMCP("getbased")
@@ -325,6 +361,167 @@ async def getbased_section(section: str = "", profile: str = "") -> str:
     return f"[{match_key}]\n\n{sections[match_key]}"
 
 
+@mcp.tool()
+@_instrumented("getbased_wearables_series")
+async def getbased_wearables_series(
+    metric: str = "",
+    days: int = 0,
+    profile: str = "",
+) -> str:
+    """Read the wearable daily-values series the user opted into pushing.
+
+    The user picks a window in Settings → Integrations → Agent Access:
+    7, 30, or 90 days (or off). When set, the browser pushes a
+    `[section:wearables-series-{N}d]` block to the gateway containing
+    one line per metric, daily values separated by `→` (oldest to
+    newest), `—` for no-reading days, and the primary source in parens.
+
+    This tool extracts that series and optionally slices it.
+
+    Args:
+        metric: optional metric id to return only one line. Examples:
+            'hrv_rmssd' (overnight HRV), 'rhr' (overnight resting HR),
+            'hr_day' (daytime HR), 'sleep_score', 'readiness_score',
+            'steps', 'weight'. Pass empty string for the whole matrix.
+        days: optional preferred window. If 0, returns whichever
+            window the user pushed. If 7/30/90, returns that section
+            specifically (404 if not pushed). The browser only pushes
+            ONE window at a time, so non-matching values fall back.
+        profile: profile id (omit for default).
+
+    Returns the section content, or a clear error if the user hasn't
+    enabled the toggle yet.
+    """
+    data = await _fetch_context(profile)
+    if "error" in data:
+        return f"Error: {data['error']}"
+    context = data.get("context", "")
+    if not context:
+        return "No context available"
+
+    sections = _parse_sections(context)
+    # Find the wearables-series-Nd section. Prefer requested `days`, else
+    # whichever the user opted into.
+    candidates = [k for k in sections if k.startswith("wearables-series-")]
+    if not candidates:
+        return (
+            "No wearable series available. The user can enable this in "
+            "getbased: Settings → Integrations → Agent Access → "
+            "'Push wearable daily series'. Pick 7, 30, or 90 days."
+        )
+
+    chosen = None
+    if days in (7, 30, 90):
+        target = f"wearables-series-{days}d"
+        chosen = next((k for k in candidates if k == target), None)
+        if not chosen:
+            available = [k.replace("wearables-series-", "").replace("d", "") for k in candidates]
+            return (
+                f"User hasn't pushed the {days}-day window. Currently "
+                f"available: {', '.join(available)} day(s). They can "
+                f"change the window in Settings → Integrations → Agent "
+                f"Access."
+            )
+    else:
+        chosen = candidates[0]
+
+    content = sections[chosen]
+    if not metric:
+        return f"[{chosen}]\n\n{content}"
+
+    # Parse one line. Lines look like:
+    #   HRV (overnight) ms (oura): 33→35→32→…→39
+    metric_lower = metric.lower().strip()
+    matched = []
+    for line in content.split("\n"):
+        if not line or line.startswith("##"):
+            continue
+        # The metric id isn't directly in the line — labels are like
+        # "HRV (overnight)" / "Resting HR" / "Steps". Match by checking
+        # whether `metric_lower` appears in the line label OR the line
+        # starts with a known label-form for that metric.
+        head = line.split(":", 1)[0].lower()
+        if metric_lower in head:
+            matched.append(line)
+            continue
+        # Common id → label-fragment aliases. Browser emits labels via
+        # `${label}${unit ? ' ' + unit : ''} (${primarySource})` where
+        # `label` is `canon.label` followed by an optional `(${canon.sub})`.
+        # For `hrv_rmssd` that produces `HRV (🌙) ms (oura)` — the literal
+        # parens around the glyph mean substring matches like "hrv 🌙"
+        # FAIL. List enough fragments per id to handle all the label forms
+        # the canonical registry can emit.
+        aliases = {
+            # HRV overnight: label="HRV", sub="🌙" → "hrv (🌙)"
+            "hrv_rmssd": ["hrv (🌙)", "hrv 🌙", "hrv (overnight)", "hrv overnight"],
+            # HRV daytime: label="HRV", sub="☀️" → "hrv (☀️)"
+            "hrv_day": ["hrv (☀", "hrv ☀", "hrv (daytime)", "hrv daytime"],
+            # HRV SDNN (Apple Health): label="HRV", sub="SDNN" → "hrv (sdnn)"
+            "hrv_sdnn": ["hrv (sdnn)", "hrv sdnn"],
+            # Resting HR: label="Resting HR", sub="" → "resting hr"
+            "rhr": ["resting hr", "resting heart"],
+            # Heart rate daytime: label="Heart rate", sub="☀️" → "heart rate (☀️)"
+            "hr_day": ["heart rate (☀", "heart rate ☀", "heart rate (daytime)", "heart rate daytime"],
+            # Sleep score: label="Sleep", sub="score" → "sleep (score)"
+            "sleep_score": ["sleep (score)", "sleep score"],
+            "readiness_score": ["readiness (score)", "readiness score"],
+            "activity_score": ["activity (score)", "activity score"],
+            "stress_high_min": ["stress"],
+            "resilience_level": ["resilience"],
+            "cardio_age": ["cardio age"],
+            "strain": ["strain (day)", "strain"],
+            "steps": ["steps"],
+            "weight": ["weight"],
+            "bp_systolic": ["bp (syst)", "bp syst", "blood pressure systolic"],
+            "bp_diastolic": ["bp (dia)", "bp dia", "blood pressure diastolic"],
+            "spo2_avg": ["spo₂", "spo2"],
+            "body_temp_delta": ["body temp", "body_temp"],
+            "glucose_avg": ["glucose"],
+            # Withings full coverage (getbased PR #140 / #143). Labels are
+            # unsubbed for body comp, but sleep architecture carries subs
+            # like "Sleep total", "Sleep HR (avg) bpm", etc.
+            "pwv": ["pwv"],
+            "vascular_age": ["vascular age"],
+            "cardio_fitness": ["cardio fit"],
+            "body_fat_pct": ["body fat"],
+            "fat_mass_kg": ["fat mass"],
+            "muscle_mass_kg": ["muscle"],
+            "lean_mass_kg": ["lean mass"],
+            "bone_mass_kg": ["bone"],
+            "water_mass_kg": ["water"],
+            "visceral_fat": ["visceral fat"],
+            "nerve_health_score": ["nerve health"],
+            "body_temp": ["body temp"],
+            "skin_temp": ["skin temp"],
+            "sleep_total_min": ["sleep total"],
+            "sleep_deep_min": ["deep sleep"],
+            "sleep_light_min": ["light sleep"],
+            "sleep_rem_min": ["rem sleep"],
+            "sleep_awake_min": ["awake (in bed)", "awake in bed"],
+            "sleep_hr_avg": ["sleep hr (avg)", "sleep hr"],
+            "sleep_breathing_rate": ["breathing (sleep)", "breathing"],
+            "sleep_snoring_min": ["snoring"],
+            "sleep_breath_disturb": ["apnea (level)", "apnea"],
+        }
+        for alias_id, label_forms in aliases.items():
+            if alias_id == metric_lower and any(lf in head for lf in label_forms):
+                matched.append(line)
+                break
+
+    if not matched:
+        # Surface the available metric labels so the agent can retry.
+        labels = []
+        for line in content.split("\n"):
+            if line and not line.startswith("##") and ":" in line:
+                labels.append(line.split(":", 1)[0].strip())
+        return (
+            f"Metric '{metric}' not found in [{chosen}]. "
+            f"Available labels: {' · '.join(labels)}"
+        )
+
+    return f"[{chosen}: {metric}]\n\n" + "\n".join(matched)
+
+
 @mcp.tool()
 @_instrumented("getbased_list_profiles")
 async def getbased_list_profiles() -> str:

{getbased_mcp-0.2.2 → getbased_mcp-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "getbased-mcp"
-version = "0.2.2"
+version = "0.2.4"
 description = "MCP server for querying blood work data and knowledge base from getbased"
 readme = "README.md"
 license = "GPL-3.0-only"

getbased_mcp-0.2.4/tests/test_env_loader.py

@@ -0,0 +1,162 @@
+"""Tests for _maybe_load_user_env in getbased_mcp.
+
+This is the critical guardrail for existing deployments like Hermes: without
+GETBASED_STACK_MANAGED=1, the loader MUST be a no-op — no filesystem access,
+no env mutation. Hermes doesn't set the flag and doesn't use the shared env
+file, so these tests protect its MCP behavior from any regression.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import pytest
+
+
+@pytest.fixture
+def env_file(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
+    """Isolated XDG_CONFIG_HOME with a getbased/env file containing a
+    sentinel value. Tests decide whether the loader sees it by toggling
+    GETBASED_STACK_MANAGED / GETBASED_NO_ENV_FILE."""
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path))
+    d = tmp_path / "getbased"
+    d.mkdir()
+    path = d / "env"
+    path.write_text("GETBASED_TOKEN=from_file\nLENS_URL=http://from-file:9999\n")
+    return path
+
+
+def _load(monkeypatch: pytest.MonkeyPatch):
+    """Freshly import and return the loader function. Reload ensures we
+    don't accidentally share state between tests."""
+    import importlib
+
+    import getbased_mcp
+
+    importlib.reload(getbased_mcp)
+    return getbased_mcp._maybe_load_user_env
+
+
+def test_noop_without_managed_flag(env_file, monkeypatch):
+    """Hermes-safety contract: no flag → no read, no mutation."""
+    monkeypatch.delenv("GETBASED_STACK_MANAGED", raising=False)
+    monkeypatch.delenv("GETBASED_TOKEN", raising=False)
+    monkeypatch.delenv("LENS_URL", raising=False)
+
+    loader = _load(monkeypatch)
+    loader()
+
+    assert "GETBASED_TOKEN" not in os.environ
+    assert "LENS_URL" not in os.environ
+
+
+def test_loads_when_managed(env_file, monkeypatch):
+    monkeypatch.setenv("GETBASED_STACK_MANAGED", "1")
+    monkeypatch.delenv("GETBASED_TOKEN", raising=False)
+    monkeypatch.delenv("LENS_URL", raising=False)
+
+    loader = _load(monkeypatch)
+    loader()
+
+    assert os.environ["GETBASED_TOKEN"] == "from_file"
+    assert os.environ["LENS_URL"] == "http://from-file:9999"
+
+
+def test_explicit_env_wins_over_file(env_file, monkeypatch):
+    """setdefault semantics — user/systemd-provided env must not be
+    overridden by the shared file."""
+    monkeypatch.setenv("GETBASED_STACK_MANAGED", "1")
+    monkeypatch.setenv("GETBASED_TOKEN", "from_shell")
+
+    loader = _load(monkeypatch)
+    loader()
+
+    assert os.environ["GETBASED_TOKEN"] == "from_shell"
+
+
+def test_escape_hatch(env_file, monkeypatch):
+    """GETBASED_NO_ENV_FILE=1 bails even when managed — debugging/override use."""
+    monkeypatch.setenv("GETBASED_STACK_MANAGED", "1")
+    monkeypatch.setenv("GETBASED_NO_ENV_FILE", "1")
+    monkeypatch.delenv("GETBASED_TOKEN", raising=False)
+
+    loader = _load(monkeypatch)
+    loader()
+
+    assert "GETBASED_TOKEN" not in os.environ
+
+
+def test_missing_file_silent(tmp_path, monkeypatch):
+    """No env file at the expected path → no error, no mutation."""
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path))
+    monkeypatch.setenv("GETBASED_STACK_MANAGED", "1")
+    monkeypatch.delenv("GETBASED_TOKEN", raising=False)
+
+    loader = _load(monkeypatch)
+    loader()  # must not raise
+
+    assert "GETBASED_TOKEN" not in os.environ
+
+
+def test_malformed_lines_skipped(tmp_path, monkeypatch):
+    """A typo'd env file must not crash MCP startup."""
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path))
+    d = tmp_path / "getbased"
+    d.mkdir()
+    (d / "env").write_text(
+        "# a comment\n"
+        "\n"
+        "NO_EQUALS_SIGN\n"
+        "GOOD_VAR=ok\n"
+        "   =missing_key\n"
+    )
+    monkeypatch.setenv("GETBASED_STACK_MANAGED", "1")
+    monkeypatch.delenv("GOOD_VAR", raising=False)
+
+    loader = _load(monkeypatch)
+    loader()
+
+    assert os.environ["GOOD_VAR"] == "ok"
+
+
+def test_quoted_values_unwrapped(tmp_path, monkeypatch):
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path))
+    d = tmp_path / "getbased"
+    d.mkdir()
+    (d / "env").write_text('DOUBLE="dv"\nSINGLE=\'sv\'\nBARE=bv\n')
+    monkeypatch.setenv("GETBASED_STACK_MANAGED", "1")
+    for k in ("DOUBLE", "SINGLE", "BARE"):
+        monkeypatch.delenv(k, raising=False)
+
+    loader = _load(monkeypatch)
+    loader()
+
+    assert os.environ["DOUBLE"] == "dv"
+    assert os.environ["SINGLE"] == "sv"
+    assert os.environ["BARE"] == "bv"
+
+
+def test_module_import_parity_without_flag(monkeypatch, tmp_path):
+    """Smoke: importing getbased_mcp without the managed flag must not
+    read or mutate anything related to the shared env file. This is the
+    end-to-end Hermes contract — if this ever fails, we risk regressing
+    a live deployment."""
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path))
+    d = tmp_path / "getbased"
+    d.mkdir()
+    # Would poison LENS_URL if the loader ran
+    (d / "env").write_text("LENS_URL=http://POISON:1234\n")
+
+    monkeypatch.delenv("GETBASED_STACK_MANAGED", raising=False)
+    monkeypatch.setenv("LENS_URL", "http://explicit:8322")
+    monkeypatch.setenv("GETBASED_TOKEN", "real")
+
+    import importlib
+
+    import getbased_mcp
+
+    importlib.reload(getbased_mcp)
+
+    # Explicit env must survive; poison must not have been loaded
+    assert getbased_mcp.LENS_URL == "http://explicit:8322"
+    assert "POISON" not in getbased_mcp.LENS_URL