Fix port handling and OAuth flow

- Remove port searching logic in favor of fixed port 3008
- Fix OAuth flow to properly use client ID from environment variables
- Add validation to ensure client credentials are properly set

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

main.py

@@ -1,9 +1,14 @@
+import logging
 from strava_mcp.server import mcp
 
+logger = logging.getLogger(__name__)
 
 def main():
     """Run the Strava MCP server."""
-    mcp.run()
+    # Use fixed port 3008
+    port = 3008
+    logger.info(f"Using port {port} for MCP server")
+    mcp.run(port=port)
 
 
 if __name__ == "__main__":

strava_mcp/api.py

@@ -19,12 +19,11 @@ class StravaAPI:
 
         Args:
             settings: Strava API settings
-            app: FastAPI app for auth routes (optional)
+            app: FastAPI app (not used, kept for backward compatibility)
         """
         self.settings = settings
         self.access_token = None
         self.token_expires_at = None
-        self.app = app
         self.auth_flow_in_progress = False
         self._client = httpx.AsyncClient(
             base_url=settings.base_url,
@@ -36,86 +35,26 @@ class StravaAPI:
         await self._client.aclose()
 
     async def setup_auth_routes(self):
-        """Set up authentication routes if app is available."""
-        if not self.app:
-            logger.warning("No FastAPI app provided, skipping auth routes setup")
-            return
-
-        from strava_mcp.auth import StravaAuthenticator
-
-        # Check if we have a FastAPI app or a FastMCP server
-        fastapi_app = None
-
-        # If it's a FastAPI app, use it directly
-        if hasattr(self.app, "add_api_route"):
-            fastapi_app = self.app
-        # If it's a FastMCP server, try to get its underlying app
-        # FastMCP doesn't have a public API for this, but we can use type checking
-        # to treat it as a FastAPI instance as it extends FastAPI
-        else:
-            # Just use the app itself since it should be a FastAPI instance or subclass
-            fastapi_app = self.app
-
-        if not fastapi_app:
-            logger.warning("Could not get FastAPI app from the provided object, auth flow will not be available")
-            return
-
-        # Create authenticator and set up routes
-        try:
-            authenticator = StravaAuthenticator(self.settings.client_id, self.settings.client_secret, fastapi_app)
-            authenticator.setup_routes(fastapi_app)
-
-            # Store authenticator for later use
-            self._authenticator = authenticator
-            logger.info("Successfully set up Strava auth routes")
-        except Exception as e:
-            logger.error(f"Error setting up auth routes: {e}")
-            return
+        """This method is deprecated and does nothing now.
+        Standalone OAuth server is used instead.
+        """
+        logger.info("Using standalone OAuth server instead of integrated auth routes")
+        return
 
     async def start_auth_flow(self) -> str:
-        """Start the auth flow to get a refresh token.
+        """This method is deprecated. 
+        The standalone OAuth server is used instead via _ensure_token().
 
         Returns:
             The refresh token
 
         Raises:
-            Exception: If the auth flow fails or is not available
+            Exception: Always raises exception directing to use standalone flow
         """
-        if not self.app:
-            raise Exception(
-                "No FastAPI app available for auth flow. "
-                "Please set STRAVA_REFRESH_TOKEN manually in your environment variables."
-            )
-
-        authenticator = getattr(self, "_authenticator", None)
-        if not authenticator:
-            raise Exception(
-                "Auth routes not set up or setup failed. "
-                "Please set STRAVA_REFRESH_TOKEN manually in your environment variables."
-            )
-
-        if self.auth_flow_in_progress:
-            raise Exception("Auth flow already in progress")
-
-        self.auth_flow_in_progress = True
-        try:
-            # Display instructions to the user and open browser
-            auth_url = self._authenticator.get_authorization_url()
-            logger.info(
-                f"\nNo refresh token available. Opening browser for authorization. "
-                f"If browser doesn't open, please visit this URL manually: {auth_url}"
-            )
-
-            # Get the refresh token and open browser automatically
-            refresh_token = await self._authenticator.get_refresh_token(open_browser=True)
-
-            # Store it in settings
-            self.settings.refresh_token = refresh_token
-
-            logger.info("Successfully obtained refresh token")
-            return refresh_token
-        finally:
-            self.auth_flow_in_progress = False
+        raise Exception(
+            "Integrated auth flow is no longer supported. "
+            "The standalone OAuth server will be used automatically when needed."
+        )
 
     async def _ensure_token(self) -> str:
         """Ensure we have a valid access token.
@@ -148,21 +87,11 @@ class StravaAPI:
                 error_msg = f"Failed to get refresh token through OAuth flow: {e}"
                 logger.error(error_msg)
 
-                # Fall back to the original auth flow if available and requested
-                if self.app and not self.auth_flow_in_progress:
-                    logger.info("Falling back to MCP-integrated auth flow")
-                    try:
-                        self.settings.refresh_token = await self.start_auth_flow()
-                    except Exception as fallback_error:
-                        raise Exception(
-                            "No refresh token available and all auth flows failed. "
-                            "Please set STRAVA_REFRESH_TOKEN manually in your environment variables."
-                        ) from fallback_error
-                else:
-                    raise Exception(
-                        "No refresh token available and OAuth flow failed. "
-                        "Please set STRAVA_REFRESH_TOKEN manually in your environment variables."
-                    ) from e
+                # No fallback to MCP-integrated auth flow anymore
+                raise Exception(
+                    "No refresh token available and OAuth flow failed. "
+                    "Please set STRAVA_REFRESH_TOKEN manually in your environment variables."
+                ) from e
 
         # Now that we have a refresh token, refresh the access token
         async with httpx.AsyncClient() as client:

strava_mcp/oauth_server.py

@@ -126,19 +126,22 @@ class StravaOAuthServer:
         if not self.app:
             raise ValueError("FastAPI app not initialized")
 
-        config = uvicorn.Config(
-            app=self.app,  # The type checker should now be satisfied
-            host=self.host,
-            port=self.port,
-            log_level="info",
-        )
-        self.server = uvicorn.Server(config)
+        # Use fixed port 3008
         try:
+            config = uvicorn.Config(
+                app=self.app,
+                host=self.host,
+                port=self.port,
+                log_level="info",
+            )
+            
+            self.server = uvicorn.Server(config)
             await self.server.serve()
         except Exception as e:
             logger.exception("Error running OAuth server")
             if not self.token_future.done():
                 self.token_future.set_exception(e)
+            raise
 
     async def _stop_server(self):
         """Stop the uvicorn server."""

strava_mcp/server.py

@@ -29,11 +29,14 @@ async def lifespan(server: FastMCP) -> AsyncIterator[dict[str, Any]]:
     """
     # Load settings from environment variables
     try:
-        settings = StravaSettings(
-            client_id="",  # Will be overridden by env vars
-            client_secret="",  # Will be overridden by env vars
-            base_url="https://www.strava.com/api/v3",
-        )
+        # Let StravaSettings load values directly from env vars
+        settings = StravaSettings()
+        
+        if not settings.client_id:
+            raise ValueError("STRAVA_CLIENT_ID environment variable is not set")
+        if not settings.client_secret:
+            raise ValueError("STRAVA_CLIENT_SECRET environment variable is not set")
+            
         logger.info("Loaded Strava API settings")
     except Exception as e:
         logger.error(f"Failed to load Strava API settings: {str(e)}")

strava_mcp/service.py

@@ -23,15 +23,12 @@ class StravaService:
         self.api = StravaAPI(settings, app)
 
     async def initialize(self):
-        """Initialize the service, setting up auth routes if needed."""
-        # Set up authentication routes if app is available
-        await self.api.setup_auth_routes()
-
-        # If we don't have a refresh token, log info about OAuth flow
+        """Initialize the service."""
+        # Log info about OAuth flow if no refresh token
         if not self.settings.refresh_token:
             logger.info(
                 "No STRAVA_REFRESH_TOKEN found in environment. "
-                "The OAuth flow will be triggered automatically when needed."
+                "The standalone OAuth flow will be triggered automatically when needed."
             )
 
     async def close(self):