strava-activity-mcp-server 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

strava_activity_mcp_server/__init__.py

@@ -1,4 +1,4 @@
-from .strava_activity_mcp_server import mcp
-def main() -> None:
-    """Run the MCP server."""
+from .strava_activity_mcp_server import mcp
+def main() -> None:
+    """Run the MCP server."""
     mcp.run()

strava_activity_mcp_server/strava_activity_mcp_server.py

@@ -5,9 +5,37 @@ mcp = FastMCP("Strava")  # Initialize an MCP server instance with a descriptive
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
 import requests
 import urllib.parse
+import json
+from typing import Any, Dict
+
+TOKEN_STORE_FILENAME = "strava_mcp_tokens.json"
+
+def _get_token_store_path() -> str:
+    home_dir = os.path.expanduser("~")
+    return os.path.join(home_dir, TOKEN_STORE_FILENAME)
+
+def _save_tokens_to_disk(tokens: Dict[str, Any]) -> dict:
+    try:
+        path = _get_token_store_path()
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(tokens, f)
+        return {"ok": True, "path": path}
+    except Exception as e:
+        return {"ok": False, "error": str(e)}
+
+def _load_tokens_from_disk() -> dict:
+    try:
+        path = _get_token_store_path()
+        if not os.path.exists(path):
+            return {"ok": False, "error": "token store not found", "path": path}
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return {"ok": True, "tokens": data, "path": path}
+    except Exception as e:
+        return {"ok": False, "error": str(e)}
 
 @mcp.tool("strava://auth/url")
-def get_auth_url(client_id: int | None = None):
+async def get_auth_url(client_id: int | None = None):
     """Return the Strava OAuth authorization URL. If client_id is not provided,
     read it from the STRAVA_CLIENT_ID environment variable."""
     if client_id is None:
@@ -30,7 +58,8 @@ def get_auth_url(client_id: int | None = None):
     return "https://www.strava.com/oauth/authorize?" + urllib.parse.urlencode(params)
 
 @mcp.tool("strava://auth/refresh")
-def refresh_access_token(
+async def refresh_access_token(
+    
     refresh_token: str,
     client_id: int | None = None,
     client_secret: str | None = None,
@@ -85,7 +114,7 @@ def refresh_access_token(
     }
 
 @mcp.tool("strava://athlete/stats")
-def get_athlete_stats(
+async def get_athlete_stats(
     code: str,
     client_id: int | None = None,
     client_secret: str | None = None,
@@ -135,6 +164,17 @@ def get_athlete_stats(
 
     access_token = tokens.get("access_token")
     refresh_token = tokens.get("refresh_token")
+    
+    # Persist tokens for later refresh usage via the public save tool
+    save_result = await save_tokens({
+        "access_token": access_token,
+        "refresh_token": refresh_token,
+        "expires_at": tokens.get("expires_at"),
+        "expires_in": tokens.get("expires_in"),
+        "athlete": tokens.get("athlete"),
+        "token_type": tokens.get("token_type"),
+        "scope": tokens.get("scope"),
+    })
 
     # return {"tokens": tokens, "access_token": access_token, "refresh_token": refresh_token}
 
@@ -145,11 +185,19 @@ def get_athlete_stats(
     }
 
     response = requests.get(url, headers=headers)
-
-    return response.json()
+    return {
+        "activities": response.json(),
+        "tokens": {
+            "access_token": access_token,
+            "refresh_token": refresh_token,
+            "expires_at": tokens.get("expires_at"),
+            "expires_in": tokens.get("expires_in"),
+        },
+        "save": save_result
+    }
 
 @mcp.tool("strava://athlete/stats-with-token")
-def get_athlete_stats_with_token(access_token: str) -> dict:
+async def get_athlete_stats_with_token(access_token: str) -> dict:
     """Get athlete activities using an existing access token."""
     if not access_token:
         return {"error": "access token is required"}
@@ -169,8 +217,82 @@ def get_athlete_stats_with_token(access_token: str) -> dict:
     except Exception as e:
         return {"error": "API request failed", "status_code": response.status_code, "response": response.text, "error": str(e)}
 
-    return response.json()
+    activities_data = response.json()
+    return {
+        "activities": activities_data,
+        "count": len(activities_data) if isinstance(activities_data, list) else 0,
+        "status": "success"
+    }
+
+@mcp.tool("strava://auth/save")
+async def save_tokens(tokens: dict | None = None) -> dict:
+    """Save tokens to local disk at ~/.strava_mcp_tokens.json. If tokens is not provided, no-op with error."""
+    if not tokens or not isinstance(tokens, dict):
+        return {"error": "tokens dict is required"}
+    result = _save_tokens_to_disk(tokens)
+    if not result.get("ok"):
+        return {"error": "failed to save tokens", **result}
+    return {"ok": True, "path": result.get("path")}
+
+
+@mcp.tool("strava://auth/load")
+async def load_tokens() -> dict:
+    """Load tokens from local disk at ~/.strava_mcp_tokens.json"""
+    result = _load_tokens_from_disk()
+    if not result.get("ok"):
+        return {"error": result.get("error"), "path": result.get("path")}
+    return {"ok": True, "tokens": result.get("tokens"), "path": result.get("path")}
+
+@mcp.tool("strava://athlete/refresh-and-stats")
+async def refresh_and_get_stats(client_id: int | None = None, client_secret: str | None = None) -> dict:
+    """Load saved refresh token, refresh access token, save it, then fetch activities."""
+    load_result = await load_tokens()
+    if not load_result.get("ok"):
+        return {"error": "no saved tokens", "details": load_result}
+    saved = load_result.get("tokens", {})
+    refresh_token = saved.get("refresh_token")
+    if not refresh_token:
+        return {"error": "refresh_token not found in saved tokens"}
+
+    refreshed = await refresh_access_token(refresh_token=refresh_token, client_id=client_id, client_secret=client_secret)
+    if "error" in refreshed:
+        return {"error": "refresh failed", "details": refreshed}
+
+    # Save refreshed tokens
+    await save_tokens(refreshed)
+
+    access_token = refreshed.get("access_token")
+    if not access_token:
+        return {"error": "no access_token after refresh"}
+
+    # Fetch activities with new token
+    activities = await get_athlete_stats_with_token(access_token)
+    return {"activities": activities, "tokens": refreshed}
+
+@mcp.tool("strava://session/start")
+async def start_session(client_id: int | None = None, client_secret: str | None = None) -> dict:
+    """Start a session: if a refresh token exists, refresh and fetch; otherwise return auth URL."""
+    token_path = _get_token_store_path()
+    if os.path.exists(token_path):
+        loaded = _load_tokens_from_disk()
+        if loaded.get("ok"):
+            saved = loaded.get("tokens", {})
+            refresh_token = saved.get("refresh_token")
+            if isinstance(refresh_token, str) and refresh_token.strip():
+                result = await refresh_and_get_stats(client_id=client_id, client_secret=client_secret)
+                return {**result, "used_token_file": token_path}
+    # Fall back to auth URL flow
+    else:
+        url = await get_auth_url(client_id=client_id)
+        return {"auth_url": url, "token_file_checked": token_path}
 
+#@mcp.prompt
+#def greet_user_prompt(question: str) -> str:
+    #"""Generates a message orchestrating mcp tools"""
+    #return f"""
+    #Return a message for a user called '{question}'. 
+    #if the user is asking, use a formal style, else use a street style.
+    #"""
 
 if __name__ == "__main__":
     mcp.run(transport="stdio")  # Run the server, using standard input/output for communication

{strava_activity_mcp_server-0.2.2.dist-info → strava_activity_mcp_server-0.2.4.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: strava-activity-mcp-server
-Version: 0.2.2
-Summary: STRAVA ACTIVITY MCP SERVER
+Version: 0.2.4
+Summary: Strava MCP server: one-time browser auth, then automatic refresh-token login
 License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: build>=1.3.0
@@ -21,6 +21,8 @@ Description-Content-Type: text/markdown
 
 A small Model Context Protocol (MCP) server that exposes your Strava athlete data to language-model tooling.
 
+After the first browser-based authorization, the server uses the saved `refresh_token` to automatically refresh your session; no further URL-redirected logins are required on subsequent runs.
+
 This package provides a lightweight MCP server which communicates with the Strava API and exposes a few helper tools (authorization URL, token exchange/refresh, and fetching athlete activities) that language models or other local tools can call.
 
 The project is intended to be used locally (for example with Claude MCP integrations) and is published on PyPI as `strava-activity-mcp-server`.
@@ -55,7 +57,7 @@ from strava_activity_mcp_server import main
 main()
 ```
 
-By default the server starts the MCP runtime; when used with an MCP-aware client (for example Claude MCP integrations) the exposed tools become callable.
+By default the server starts the MCP runtime; when used with an MCP-aware client (for example Msty MCP orsome other MCP integrations such Claude, LM Tool and etc.) the exposed tools become callable.
 
 ## Authentication (Strava OAuth)
 
@@ -63,28 +65,54 @@ This server requires Strava OAuth credentials to access athlete data. You will n
 
 - STRAVA_CLIENT_ID
 - STRAVA_CLIENT_SECRET
-- STRAVA_REFRESH_TOKEN (or a short-lived access token obtained from the authorization flow)
 
 Steps:
 
 1. Create a Strava API application at https://www.strava.com/settings/api and note your Client ID and Client Secret. Use `localhost` as the Authorization Callback Domain.
-2. Open the authorization URL produced by the `strava://auth/url` tool (see IMAGE below) in a browser to obtain an authorization code.
+2. Initial authorization: call the `strava://auth/url` tool to generate an authorization URL (see IMAGE below), open it in your browser, and grant access. This step is only needed the first time to obtain an authorization code.
 
    ![auth](https://github.com/user-attachments/assets/a348ccc7-a4be-49fb-8f79-b88f9d80cfc9)
 
-3. Copy the code from the redirected URL (Image below) or use the included helper to save refresh/access tokens to your environment.
+3. Copy the `code` from the redirected URL (Image below). Use the provided tools to exchange it for access/refresh tokens.
 
    ![code](https://github.com/user-attachments/assets/0bb54edb-c9f9-4416-8fb2-c7e0a38d11c9)
 
 
-## Exposed Tools (what the server provides)
+4. After the initial authorization, a token file named `strava_mcp_tokens.json` is created and stored in your home directory (for example on Windows: `C:\\Users\\<YourUserName>\\strava_mcp_tokens.json`). This file contains your `refresh_token`, which will be used automatically for subsequent logins. After the first authorization you do not need to open the browser flow again; future runs refresh the access token from the locally stored `refresh_token`.
+
 
-The MCP server exposes the following tools (tool IDs shown):
 
-- `strava://auth/url` — Build the Strava OAuth authorization URL. Input: `client_id` (int). Output: URL string to open in a browser.
-- `strava://athlete/stats` — Fetch recent athlete activities. Input: `client_id` (int), `client_secret` (str), `access_token` (str) and obtained `code` from URL generated by `strava://auth/url`. Output: JSON with activity list.
 
-These tools map to the functions implemented in `src/strava_activity_mcp_server/strava_activity_mcp_server.py` and are intended to be called by MCP clients.
+## Exposed Tools (what the server provides)
+
+The MCP server exposes the following tools (tool IDs shown). These map to functions in `src/strava_activity_mcp_server/strava_activity_mcp_server.py` and cover both initial authorization and subsequent refresh flows:
+
+- `strava://auth/url` — Build the Strava OAuth authorization URL.
+  - Inputs: `client_id` (int, optional; reads `STRAVA_CLIENT_ID` if omitted)
+  - Output: Authorization URL string
+- `strava://auth/refresh` — Refresh an access token using a refresh token.
+  - Inputs: `refresh_token` (str), `client_id` (int, optional), `client_secret` (str, optional)
+  - Output: `{ access_token, refresh_token, expires_at, expires_in }`
+- `strava://athlete/stats` — Exchange an authorization `code` for tokens and then fetch recent activities.
+  - Inputs: `code` (str), `client_id` (int, optional), `client_secret` (str, optional)
+  - Output: `{ activities, tokens, save }`
+- `strava://athlete/stats-with-token` — Fetch recent activities using an existing access token.
+  - Inputs: `access_token` (str)
+  - Output: Activity list (JSON)
+- `strava://auth/save` — Save tokens to `~\strava_mcp_tokens.json`.
+  - Inputs: `tokens` (dict)
+  - Output: `{ ok, path }` or error
+- `strava://auth/load` — Load tokens from `~\strava_mcp_tokens.json`.
+  - Inputs: none
+  - Output: `{ ok, tokens, path }` or error
+- `strava://athlete/refresh-and-stats` — Load saved refresh token, refresh access token, save it, and fetch activities.
+  - Inputs: `client_id` (int, optional), `client_secret` (str, optional)
+  - Output: `{ activities, tokens }`
+- `strava://session/start` — Convenience entry: if tokens exist, refresh and fetch; otherwise return an auth URL to begin initial authorization.
+  - Inputs: `client_id` (int, optional), `client_secret` (str, optional)
+  - Output: Either `{ activities, tokens }` or `{ auth_url, token_file_checked }`
+
+These tools are intended to be called by MCP clients.
 
 ## Example flows
 
@@ -109,8 +137,7 @@ Any MCP-capable client can launch the server using a config similar to the follo
   ],
   "env": {
     "STRAVA_CLIENT_ID": "12345",
-    "STRAVA_CLIENT_SECRET": "e1234a12d12345f12c1f12345a123bba1d12c1",
-    "STRAVA_REFRESH_TOKEN": "1a123eda1cfd12345678987db2db1bda234c38"
+    "STRAVA_CLIENT_SECRET": "e1234a12d12345f12c1f12345a123bba1d12c1"
   }
 }
 ```

strava_activity_mcp_server-0.2.4.dist-info/RECORD

@@ -0,0 +1,8 @@
+strava_activity_mcp_server/__init__.py,sha256=NgXC8CeBg0qFRHdZJJKjQlX9_RwSETJ9O6PNy0leOTI,107
+strava_activity_mcp_server/__main__.py,sha256=SAdVoObdjb5UP4MY-Y2_uCXpnthB6hgxlb1KNVNgOrc,58
+strava_activity_mcp_server/strava_activity_mcp_server.py,sha256=0ipTrX7ydrDaATRhyvCO5wseprC96-tT2XVkXB_h3Ok,11643
+strava_activity_mcp_server-0.2.4.dist-info/METADATA,sha256=KoVyfCThPzgXfsaK7fGgKPjDHNoI3DSURmhY6uW_MNE,7665
+strava_activity_mcp_server-0.2.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+strava_activity_mcp_server-0.2.4.dist-info/entry_points.txt,sha256=F6PO_DBSThhtmX2AC-tu2MIiCJkGi31LCaQJxfUzZ5g,79
+strava_activity_mcp_server-0.2.4.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+strava_activity_mcp_server-0.2.4.dist-info/RECORD,,

strava_activity_mcp_server-0.2.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-strava_activity_mcp_server/__init__.py,sha256=jaa1ZVuEJMwuVGzj67oqC_ESUUiwblVVH-NEtTiQQdQ,110
-strava_activity_mcp_server/__main__.py,sha256=SAdVoObdjb5UP4MY-Y2_uCXpnthB6hgxlb1KNVNgOrc,58
-strava_activity_mcp_server/strava_activity_mcp_server.py,sha256=3qxN4c8cLlVlv4R1e90c8AOsw6WaCOy4PMz2GwXsCwE,6515
-strava_activity_mcp_server-0.2.2.dist-info/METADATA,sha256=y2L0izsArgmYkPOp2MRvSjewbnhkAan6Q1bNUMtNexQ,5678
-strava_activity_mcp_server-0.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-strava_activity_mcp_server-0.2.2.dist-info/entry_points.txt,sha256=F6PO_DBSThhtmX2AC-tu2MIiCJkGi31LCaQJxfUzZ5g,79
-strava_activity_mcp_server-0.2.2.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-strava_activity_mcp_server-0.2.2.dist-info/RECORD,,