Remove dead code, fix SSE timeout, and correct GET test

- Remove unused `BoardDetail::get_work_item_types()` and `HashSet` import
- Remove 60s connection timeout that would kill SSE streams; MCP
  Streamable HTTP uses GET for long-lived SSE connections
- Fix invalid-method test to use PUT instead of GET (GET is valid for SSE)
- Add `test_http_server_accepts_get_for_sse` verifying GET is accepted

Author: danielealbano

src/azure/boards.rs

@@ -1,7 +1,6 @@
 use crate::azure::client::{AzureDevOpsClient, AzureError};
 use reqwest::Method;
 use serde::{Deserialize, Serialize};
-use std::collections::HashSet;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Team {
@@ -118,27 +117,6 @@ pub struct BoardDetail {
     // Skipping _links as it's not needed
 }
 
-impl BoardDetail {
-    /// Extract work item types from the board's allowed mappings
-    pub fn get_work_item_types(&self) -> Vec<String> {
-        let mut types = HashSet::new();
-
-        if let Some(mappings) = &self.allowed_mappings
-            && let Some(obj) = mappings.as_object()
-        {
-            for (_column_type, type_mappings) in obj {
-                if let Some(type_obj) = type_mappings.as_object() {
-                    for (work_item_type, _states) in type_obj {
-                        types.insert(work_item_type.clone());
-                    }
-                }
-            }
-        }
-
-        types.into_iter().collect()
-    }
-}
-
 #[derive(Debug, Serialize, Deserialize)]
 pub struct BoardListResponse {
     pub value: Vec<BoardSummary>,

src/server/http.rs

@@ -8,11 +8,9 @@ use rmcp::transport::streamable_http_server::{
     StreamableHttpService, session::local::LocalSessionManager,
 };
 use std::sync::Arc;
-use std::time::Duration;
 use tokio::sync::Semaphore;
 
 const MAX_CONNECTIONS: usize = 256;
-const CONNECTION_TIMEOUT: Duration = Duration::from_secs(60);
 
 pub async fn run_server(
     server: AzureMcpServer,
@@ -39,16 +37,11 @@ pub async fn run_server(
         let service = service.clone();
 
         tokio::spawn(async move {
-            let result = tokio::time::timeout(
-                CONNECTION_TIMEOUT,
-                Builder::new(TokioExecutor::default()).serve_connection(io, service),
-            )
-            .await;
-
-            match result {
-                Ok(Ok(())) => {}
-                Ok(Err(err)) => log::error!("Error serving connection: {:?}", err),
-                Err(_) => log::warn!("Connection timed out after {:?}", CONNECTION_TIMEOUT),
+            if let Err(err) = Builder::new(TokioExecutor::default())
+                .serve_connection(io, service)
+                .await
+            {
+                log::error!("Error serving connection: {:?}", err);
             }
 
             drop(permit);

tests/test_server_http.rs

@@ -53,17 +53,53 @@ mod tests {
 
         let client = reqwest::Client::new();
         let response = client
-            .get(format!("http://{}/mcp", addr))
+            .put(format!("http://{}/mcp", addr))
             .send()
             .await
             .unwrap();
 
         assert!(
-            !response.status().is_success() || response.status().as_u16() == 405,
-            "GET should not succeed with 2xx (or should be 405), got {}",
+            !response.status().is_success(),
+            "PUT should not succeed, got {}",
             response.status()
         );
 
         server_handle.abort();
     }
+
+    #[tokio::test]
+    async fn test_http_server_accepts_get_for_sse() {
+        let mock = MockAzureDevOpsApi::new();
+        let server = AzureMcpServer::new_with_api(mock);
+
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+
+        let server_handle = tokio::spawn(async move {
+            let _ = http::run_server(server, listener).await;
+        });
+
+        tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+
+        let client = reqwest::Client::new();
+        let response = client
+            .get(format!("http://{}/mcp", addr))
+            .header("Accept", "text/event-stream")
+            .send()
+            .await
+            .unwrap();
+
+        let status = response.status().as_u16();
+        assert!(
+            status != 405,
+            "GET /mcp must be a supported method for SSE streams, got 405 Method Not Allowed",
+        );
+        assert!(
+            status == 200 || status == 400 || status == 401,
+            "GET /mcp for SSE should return 200 (stream), 400 (bad request), or 401 (no session), got {}",
+            status
+        );
+
+        server_handle.abort();
+    }
 }