Merge branch 'ihrpr/shttp' into ihrpr/shttp-docs

Author: ihrpr

src/mcp/cli/claude.py

@@ -2,6 +2,7 @@
 
 import json
 import os
+import shutil
 import sys
 from pathlib import Path
 from typing import Any
@@ -30,6 +31,16 @@ def get_claude_config_path() -> Path | None:
         return path
     return None
 
+def get_uv_path() -> str:
+    """Get the full path to the uv executable."""
+    uv_path = shutil.which("uv")
+    if not uv_path:
+        logger.error(
+            "uv executable not found in PATH, falling back to 'uv'. "
+            "Please ensure uv is installed and in your PATH"
+        )
+        return "uv"  # Fall back to just "uv" if not found
+    return uv_path
 
 def update_claude_config(
     file_spec: str,
@@ -54,6 +65,7 @@ def update_claude_config(
             Claude Desktop may not be installed or properly set up.
     """
     config_dir = get_claude_config_path()
+    uv_path = get_uv_path()
     if not config_dir:
         raise RuntimeError(
             "Claude Desktop config directory not found. Please ensure Claude Desktop"
@@ -117,7 +129,7 @@ def update_claude_config(
         # Add fastmcp run command
         args.extend(["mcp", "run", file_spec])
 
-        server_config: dict[str, Any] = {"command": "uv", "args": args}
+        server_config: dict[str, Any] = {"command": uv_path, "args": args}
 
         # Add environment variables if specified
         if env_vars:

src/mcp/server/streamable_http_manager.py

@@ -4,6 +4,7 @@
 
 import contextlib
 import logging
+import threading
 from collections.abc import AsyncIterator
 from http import HTTPStatus
 from typing import Any
@@ -37,6 +38,10 @@ class StreamableHTTPSessionManager:
     3. Connection management and lifecycle
     4. Request handling and transport setup
 
+    Important: Only one StreamableHTTPSessionManager instance should be created
+    per application. The instance cannot be reused after its run() context has
+    completed. If you need to restart the manager, create a new instance.
+
     Args:
         app: The MCP server instance
         event_store: Optional event store for resumability support.
@@ -67,6 +72,9 @@ def __init__(
 
         # The task group will be set during lifespan
         self._task_group = None
+        # Thread-safe tracking of run() calls
+        self._run_lock = threading.Lock()
+        self._has_started = False
 
     @contextlib.asynccontextmanager
     async def run(self) -> AsyncIterator[None]:
@@ -75,13 +83,26 @@ async def run(self) -> AsyncIterator[None]:
 
         This creates and manages the task group for all session operations.
 
+        Important: This method can only be called once per instance. The same
+        StreamableHTTPSessionManager instance cannot be reused after this
+        context manager exits. Create a new instance if you need to restart.
+
         Use this in the lifespan context manager of your Starlette app:
 
         @contextlib.asynccontextmanager
         async def lifespan(app: Starlette) -> AsyncIterator[None]:
             async with session_manager.run():
                 yield
         """
+        # Thread-safe check to ensure run() is only called once
+        with self._run_lock:
+            if self._has_started:
+                raise RuntimeError(
+                    "StreamableHTTPSessionManager .run() can only be called "
+                    "once per instance. Create a new instance if you need to run again."
+                )
+            self._has_started = True
+
         async with anyio.create_task_group() as tg:
             # Store the task group for later use
             self._task_group = tg
@@ -113,9 +134,7 @@ async def handle_request(
             send: ASGI send function
         """
         if self._task_group is None:
-            raise RuntimeError(
-                "Task group is not initialized. Make sure to use the run()."
-            )
+            raise RuntimeError("Task group is not initialized. Make sure to use run().")
 
         # Dispatch to the appropriate handler
         if self.stateless:

tests/client/test_config.py

@@ -48,3 +48,28 @@ def test_command_execution(mock_config_path: Path):
 
     assert result.returncode == 0
     assert "usage" in result.stdout.lower()
+
+
+def test_absolute_uv_path(mock_config_path: Path):
+    """Test that the absolute path to uv is used when available."""
+    # Mock the shutil.which function to return a fake path
+    mock_uv_path = "/usr/local/bin/uv"
+    
+    with patch("mcp.cli.claude.get_uv_path", return_value=mock_uv_path):
+        # Setup
+        server_name = "test_server"
+        file_spec = "test_server.py:app"
+
+        # Update config
+        success = update_claude_config(file_spec=file_spec, server_name=server_name)
+        assert success
+
+        # Read the generated config
+        config_file = mock_config_path / "claude_desktop_config.json"
+        config = json.loads(config_file.read_text())
+
+        # Verify the command is the absolute path
+        server_config = config["mcpServers"][server_name]
+        command = server_config["command"]
+        
+        assert command == mock_uv_path

tests/server/test_streamable_http_manager.py

@@ -0,0 +1,81 @@
+"""Tests for StreamableHTTPSessionManager."""
+
+import anyio
+import pytest
+
+from mcp.server.lowlevel import Server
+from mcp.server.streamable_http_manager import StreamableHTTPSessionManager
+
+
+@pytest.mark.anyio
+async def test_run_can_only_be_called_once():
+    """Test that run() can only be called once per instance."""
+    app = Server("test-server")
+    manager = StreamableHTTPSessionManager(app=app)
+
+    # First call should succeed
+    async with manager.run():
+        pass
+
+    # Second call should raise RuntimeError
+    with pytest.raises(RuntimeError) as excinfo:
+        async with manager.run():
+            pass
+
+    assert (
+        "StreamableHTTPSessionManager .run() can only be called once per instance"
+        in str(excinfo.value)
+    )
+
+
+@pytest.mark.anyio
+async def test_run_prevents_concurrent_calls():
+    """Test that concurrent calls to run() are prevented."""
+    app = Server("test-server")
+    manager = StreamableHTTPSessionManager(app=app)
+
+    errors = []
+
+    async def try_run():
+        try:
+            async with manager.run():
+                # Simulate some work
+                await anyio.sleep(0.1)
+        except RuntimeError as e:
+            errors.append(e)
+
+    # Try to run concurrently
+    async with anyio.create_task_group() as tg:
+        tg.start_soon(try_run)
+        tg.start_soon(try_run)
+
+    # One should succeed, one should fail
+    assert len(errors) == 1
+    assert (
+        "StreamableHTTPSessionManager .run() can only be called once per instance"
+        in str(errors[0])
+    )
+
+
+@pytest.mark.anyio
+async def test_handle_request_without_run_raises_error():
+    """Test that handle_request raises error if run() hasn't been called."""
+    app = Server("test-server")
+    manager = StreamableHTTPSessionManager(app=app)
+
+    # Mock ASGI parameters
+    scope = {"type": "http", "method": "POST", "path": "/test"}
+
+    async def receive():
+        return {"type": "http.request", "body": b""}
+
+    async def send(message):
+        pass
+
+    # Should raise error because run() hasn't been called
+    with pytest.raises(RuntimeError) as excinfo:
+        await manager.handle_request(scope, receive, send)
+
+    assert "Task group is not initialized. Make sure to use run()." in str(
+        excinfo.value
+    )