strava-activity-mcp-server 0.2.2__tar.gz → 0.2.4__tar.gz

{strava_activity_mcp_server-0.2.2 → strava_activity_mcp_server-0.2.4}/.python-version

@@ -1 +1 @@
-3.13
+3.13

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

@@ -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.2 → strava_activity_mcp_server-0.2.4}/README.md

@@ -10,6 +10,8 @@
 
 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`.
@@ -44,7 +46,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)
 
@@ -52,28 +54,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
 
@@ -98,8 +126,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.2 → strava_activity_mcp_server-0.2.4}/pyproject.toml

@@ -1,21 +1,21 @@
-[project]
-name = "strava-activity-mcp-server"
-version = "0.2.2"
-description = "STRAVA ACTIVITY MCP SERVER"
-readme = "README.md"
-requires-python = ">=3.10"
-dependencies = [
-    "build>=1.3.0",
-    "mcp[cli]>=1.16.0",
-    "twine>=6.2.0",
-]
-
-[project.scripts]
-strava-activity-mcp-server = "strava_activity_mcp_server:main"
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/strava_activity_mcp_server"]
+[project]
+name = "strava-activity-mcp-server"
+version = "0.2.4"
+description = "Strava MCP server: one-time browser auth, then automatic refresh-token login"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "build>=1.3.0",
+    "mcp[cli]>=1.16.0",
+    "twine>=6.2.0",
+]
+
+[project.scripts]
+strava-activity-mcp-server = "strava_activity_mcp_server:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/strava_activity_mcp_server"]

strava_activity_mcp_server-0.2.4/ref/prompts.md

@@ -0,0 +1,231 @@
+Title: Prompts - Model Context Protocol
+
+URL Source: http://modelcontextprotocol.io/specification/2025-06-18/server/prompts
+
+Markdown Content:
+The Model Context Protocol (MCP) provides a standardized way for servers to expose prompt templates to clients. Prompts allow servers to provide structured messages and instructions for interacting with language models. Clients can discover available prompts, retrieve their contents, and provide arguments to customize them.
+
+User Interaction Model
+----------------------
+
+Prompts are designed to be **user-controlled**, meaning they are exposed from servers to clients with the intention of the user being able to explicitly select them for use.Typically, prompts would be triggered through user-initiated commands in the user interface, which allows users to naturally discover and invoke available prompts.For example, as slash commands:![Image 1: Example of prompt exposed as slash command](https://mintcdn.com/mcp/4ZXF1PrDkEaJvXpn/specification/2025-06-18/server/slash-command.png?fit=max&auto=format&n=4ZXF1PrDkEaJvXpn&q=85&s=7f003e36d881dd6f3e5b8cbdd85e5ca5)However, implementors are free to expose prompts through any interface pattern that suits their needs—the protocol itself does not mandate any specific user interaction model.
+
+Capabilities
+------------
+
+Servers that support prompts **MUST** declare the `prompts` capability during [initialization](https://modelcontextprotocol.io/specification/2025-06-18/basic/lifecycle#initialization):
+
+```
+{
+  "capabilities": {
+    "prompts": {
+      "listChanged": true
+    }
+  }
+}
+```
+
+`listChanged` indicates whether the server will emit notifications when the list of available prompts changes.
+
+Protocol Messages
+-----------------
+
+### Listing Prompts
+
+To retrieve available prompts, clients send a `prompts/list` request. This operation supports [pagination](https://modelcontextprotocol.io/specification/2025-06-18/server/utilities/pagination).**Request:**
+
+```
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "prompts/list",
+  "params": {
+    "cursor": "optional-cursor-value"
+  }
+}
+```
+
+**Response:**
+
+```
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": {
+    "prompts": [
+      {
+        "name": "code_review",
+        "title": "Request Code Review",
+        "description": "Asks the LLM to analyze code quality and suggest improvements",
+        "arguments": [
+          {
+            "name": "code",
+            "description": "The code to review",
+            "required": true
+          }
+        ]
+      }
+    ],
+    "nextCursor": "next-page-cursor"
+  }
+}
+```
+
+### Getting a Prompt
+
+To retrieve a specific prompt, clients send a `prompts/get` request. Arguments may be auto-completed through [the completion API](https://modelcontextprotocol.io/specification/2025-06-18/server/utilities/completion).**Request:**
+
+```
+{
+  "jsonrpc": "2.0",
+  "id": 2,
+  "method": "prompts/get",
+  "params": {
+    "name": "code_review",
+    "arguments": {
+      "code": "def hello():\n    print('world')"
+    }
+  }
+}
+```
+
+**Response:**
+
+```
+{
+  "jsonrpc": "2.0",
+  "id": 2,
+  "result": {
+    "description": "Code review prompt",
+    "messages": [
+      {
+        "role": "user",
+        "content": {
+          "type": "text",
+          "text": "Please review this Python code:\ndef hello():\n    print('world')"
+        }
+      }
+    ]
+  }
+}
+```
+
+### List Changed Notification
+
+When the list of available prompts changes, servers that declared the `listChanged` capability **SHOULD** send a notification:
+
+```
+{
+  "jsonrpc": "2.0",
+  "method": "notifications/prompts/list_changed"
+}
+```
+
+Message Flow
+------------
+
+Data Types
+----------
+
+### Prompt
+
+A prompt definition includes:
+
+*   `name`: Unique identifier for the prompt
+*   `title`: Optional human-readable name of the prompt for display purposes.
+*   `description`: Optional human-readable description
+*   `arguments`: Optional list of arguments for customization
+
+### PromptMessage
+
+Messages in a prompt can contain:
+
+*   `role`: Either “user” or “assistant” to indicate the speaker
+*   `content`: One of the following content types:
+
+#### Text Content
+
+Text content represents plain text messages:
+
+```
+{
+  "type": "text",
+  "text": "The text content of the message"
+}
+```
+
+This is the most common content type used for natural language interactions.
+
+#### Image Content
+
+Image content allows including visual information in messages:
+
+```
+{
+  "type": "image",
+  "data": "base64-encoded-image-data",
+  "mimeType": "image/png"
+}
+```
+
+The image data **MUST** be base64-encoded and include a valid MIME type. This enables multi-modal interactions where visual context is important.
+
+#### Audio Content
+
+Audio content allows including audio information in messages:
+
+```
+{
+  "type": "audio",
+  "data": "base64-encoded-audio-data",
+  "mimeType": "audio/wav"
+}
+```
+
+The audio data MUST be base64-encoded and include a valid MIME type. This enables multi-modal interactions where audio context is important.
+
+#### Embedded Resources
+
+Embedded resources allow referencing server-side resources directly in messages:
+
+```
+{
+  "type": "resource",
+  "resource": {
+    "uri": "resource://example",
+    "name": "example",
+    "title": "My Example Resource",
+    "mimeType": "text/plain",
+    "text": "Resource content"
+  }
+}
+```
+
+Resources can contain either text or binary (blob) data and **MUST** include:
+
+*   A valid resource URI
+*   The appropriate MIME type
+*   Either text content or base64-encoded blob data
+
+Embedded resources enable prompts to seamlessly incorporate server-managed content like documentation, code samples, or other reference materials directly into the conversation flow.
+
+Error Handling
+--------------
+
+Servers **SHOULD** return standard JSON-RPC errors for common failure cases:
+
+*   Invalid prompt name: `-32602` (Invalid params)
+*   Missing required arguments: `-32602` (Invalid params)
+*   Internal errors: `-32603` (Internal error)
+
+Implementation Considerations
+-----------------------------
+
+1.   Servers **SHOULD** validate prompt arguments before processing
+2.   Clients **SHOULD** handle pagination for large prompt lists
+3.   Both parties **SHOULD** respect capability negotiation
+
+Security
+--------
+
+Implementations **MUST** carefully validate all prompt inputs and outputs to prevent injection attacks or unauthorized access to resources.

{strava_activity_mcp_server-0.2.2 → strava_activity_mcp_server-0.2.4}/src/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-0.2.2 → strava_activity_mcp_server-0.2.4}/src/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 → strava_activity_mcp_server-0.2.4}/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 2
 requires-python = ">=3.10"
 
 [[package]]
@@ -1031,7 +1031,7 @@ wheels = [
 
 [[package]]
 name = "strava-activity-mcp-server"
-version = "0.2.2"
+version = "0.2.4"
 source = { editable = "." }
 dependencies = [
     { name = "build" },