mcp-sharepoint-us 2.0.14__tar.gz → 2.0.16__tar.gz

{mcp_sharepoint_us-2.0.14 → mcp_sharepoint_us-2.0.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-sharepoint-us
-Version: 2.0.14
+Version: 2.0.16
 Summary: SharePoint MCP Server with Microsoft Graph API
 License: MIT
 Project-URL: Homepage, https://github.com/mdev26/mcp-sharepoint-us

{mcp_sharepoint_us-2.0.14 → mcp_sharepoint_us-2.0.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mcp-sharepoint-us"
-version = "2.0.14"
+version = "2.0.16"
 description = "SharePoint MCP Server with Microsoft Graph API"
 readme = "README.md"
 requires-python = ">=3.10"

{mcp_sharepoint_us-2.0.14 → mcp_sharepoint_us-2.0.16}/src/mcp_sharepoint/graph_api.py

@@ -5,9 +5,13 @@ Primary API for all SharePoint operations in Azure Government Cloud.
 import os
 import logging
 import asyncio
+import socket
+import ssl
 from typing import Optional, Dict, Any, List
 from urllib.parse import urlparse, quote
 import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
 
 logger = logging.getLogger(__name__)
 
@@ -40,6 +44,126 @@ class GraphAPIClient:
             self.graph_endpoint = "https://graph.microsoft.com/v1.0"
             logger.info("Using Microsoft Graph Commercial endpoint")
 
+        # Create a requests session with retry logic
+        self._session = self._create_session()
+
+    def _create_session(self) -> requests.Session:
+        """
+        Create a requests session with retry logic and connection pooling.
+        """
+        session = requests.Session()
+
+        # Configure retry strategy for transient errors
+        retry_strategy = Retry(
+            total=3,  # Total number of retries
+            backoff_factor=1,  # Wait 1, 2, 4 seconds between retries
+            status_forcelist=[429, 500, 502, 503, 504],  # Retry on these HTTP status codes
+            allowed_methods=["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE", "POST"]
+        )
+
+        adapter = HTTPAdapter(max_retries=retry_strategy, pool_connections=10, pool_maxsize=10)
+        session.mount("http://", adapter)
+        session.mount("https://", adapter)
+
+        logger.debug("Created requests session with retry logic and connection pooling")
+        return session
+
+    def _diagnose_connectivity(self, url: str) -> None:
+        """
+        Perform detailed connectivity diagnostics for a URL.
+
+        Args:
+            url: The URL to diagnose
+        """
+        parsed = urlparse(url)
+        hostname = parsed.hostname
+        port = parsed.port or (443 if parsed.scheme == "https" else 80)
+
+        logger.info(f"=== CONNECTIVITY DIAGNOSTICS for {hostname} ===")
+
+        # 1. DNS Resolution
+        try:
+            logger.info(f"[DNS] Resolving {hostname}...")
+            ip_addresses = socket.getaddrinfo(hostname, port, socket.AF_UNSPEC, socket.SOCK_STREAM)
+            for family, socktype, proto, canonname, sockaddr in ip_addresses:
+                family_name = "IPv4" if family == socket.AF_INET else "IPv6"
+                logger.info(f"[DNS] ✓ Resolved to {sockaddr[0]} ({family_name})")
+        except socket.gaierror as e:
+            logger.error(f"[DNS] ✗ DNS resolution failed: {e}")
+            return
+        except Exception as e:
+            logger.error(f"[DNS] ✗ Unexpected error during DNS resolution: {e}")
+            return
+
+        # 2. TCP Connection Test
+        try:
+            logger.info(f"[TCP] Testing TCP connection to {hostname}:{port}...")
+            with socket.create_connection((hostname, port), timeout=10) as sock:
+                logger.info(f"[TCP] ✓ TCP connection successful")
+                peer_name = sock.getpeername()
+                logger.info(f"[TCP] Connected to {peer_name[0]}:{peer_name[1]}")
+
+                # 3. SSL/TLS Test (if HTTPS)
+                if parsed.scheme == "https":
+                    logger.info(f"[TLS] Testing TLS handshake to {hostname}...")
+                    logger.info(f"[TLS] This will attempt to establish encrypted HTTPS connection")
+                    context = ssl.create_default_context()
+                    try:
+                        with context.wrap_socket(sock, server_hostname=hostname) as ssock:
+                            logger.info(f"[TLS] ✓ TLS handshake successful")
+                            logger.info(f"[TLS] Protocol: {ssock.version()}")
+                            cipher = ssock.cipher()
+                            if cipher:
+                                logger.info(f"[TLS] Cipher: {cipher[0]} (bits: {cipher[2]})")
+
+                            # Get certificate info
+                            cert = ssock.getpeercert()
+                            if cert:
+                                subject = dict(x[0] for x in cert['subject'])
+                                logger.info(f"[TLS] Certificate subject: {subject.get('commonName', 'N/A')}")
+                                logger.info(f"[TLS] Certificate issuer: {dict(x[0] for x in cert['issuer']).get('organizationName', 'N/A')}")
+                    except ssl.SSLError as e:
+                        logger.error(f"[TLS] ✗ TLS/SSL handshake failed: {e}")
+                        logger.error(f"[TLS] This could indicate:")
+                        logger.error(f"[TLS]   - Certificate validation failure")
+                        logger.error(f"[TLS]   - TLS version mismatch")
+                        logger.error(f"[TLS]   - Cipher suite incompatibility")
+                        return
+                    except ConnectionResetError as e:
+                        logger.error(f"[TLS] ✗ Connection reset during TLS handshake")
+                        logger.error(f"[TLS] TCP connection was established BUT connection dropped during TLS negotiation")
+                        logger.error(f"[TLS] This indicates:")
+                        logger.error(f"[TLS]   - Firewall is doing deep packet inspection (DPI)")
+                        logger.error(f"[TLS]   - Firewall is blocking TLS connections to {hostname}")
+                        logger.error(f"[TLS]   - SNI (Server Name Indication) filtering is active")
+                        logger.error(f"[TLS]")
+                        logger.error(f"[TLS] SOLUTION: Ask network team to whitelist {hostname} in firewall")
+                        logger.error(f"[TLS] The firewall needs to allow TLS/HTTPS traffic to this endpoint")
+                        return
+        except socket.timeout:
+            logger.error(f"[TCP] ✗ Connection timeout after 10 seconds")
+            return
+        except ConnectionRefusedError:
+            logger.error(f"[TCP] ✗ Connection refused by server")
+            return
+        except ConnectionResetError:
+            logger.error(f"[TCP] ✗ Connection reset by peer during TCP handshake")
+            return
+        except Exception as e:
+            logger.error(f"[TCP] ✗ Connection failed: {type(e).__name__}: {e}")
+            return
+
+        # 4. HTTP Basic Connectivity Test
+        try:
+            logger.info(f"[HTTP] Testing basic HTTP GET to {parsed.scheme}://{hostname}/")
+            test_url = f"{parsed.scheme}://{hostname}/"
+            response = self._session.get(test_url, timeout=10)
+            logger.info(f"[HTTP] ✓ Basic HTTP request successful (status: {response.status_code})")
+        except requests.exceptions.RequestException as e:
+            logger.error(f"[HTTP] ✗ Basic HTTP request failed: {type(e).__name__}: {e}")
+
+        logger.info(f"=== END DIAGNOSTICS ===\n")
+
     def _get_headers(self) -> Dict[str, str]:
         """Get authorization headers with access token."""
         logger.debug("Getting authorization headers...")
@@ -109,16 +233,66 @@ class GraphAPIClient:
             url = f"{self.graph_endpoint}/sites/{hostname}:/{path}"
 
         logger.info(f"Fetching site ID from: {url}")
+
+        # Get headers and log sanitized version
+        headers = self._get_headers()
+        sanitized_headers = {k: (v[:20] + "..." if k == "Authorization" else v) for k, v in headers.items()}
+        logger.debug(f"Request headers: {sanitized_headers}")
+
         try:
-            response = requests.get(url, headers=self._get_headers(), timeout=30)
-            logger.debug(f"Response status: {response.status_code}")
+            # Make the request
+            logger.debug(f"Sending GET request to: {url}")
+            logger.debug(f"Timeout: 30 seconds")
+
+            response = self._session.get(url, headers=headers, timeout=30)
+
+            logger.debug(f"Response received - Status: {response.status_code}")
+            logger.debug(f"Response headers: {dict(response.headers)}")
+            logger.debug(f"Response encoding: {response.encoding}")
+
             self._handle_response(response)
 
             self._site_id = response.json()["id"]
-            logger.info(f"Retrieved site ID: {self._site_id}")
+            logger.info(f"✓ Retrieved site ID: {self._site_id}")
             return self._site_id
+
+        except requests.exceptions.ConnectionError as e:
+            logger.error(f"✗ ConnectionError getting site ID: {e}", exc_info=True)
+            logger.error("This indicates the connection was established but then dropped.")
+            logger.error("Running comprehensive diagnostics to identify the exact failure point...")
+            logger.error("")
+
+            # Run diagnostics to help identify the issue
+            self._diagnose_connectivity(url)
+
+            logger.error("")
+            logger.error("=" * 70)
+            logger.error("DIAGNOSIS COMPLETE")
+            logger.error("=" * 70)
+            logger.error("")
+            logger.error("Most common causes of 'Connection reset by peer':")
+            logger.error("")
+            logger.error("1. ⚠️  FIREWALL BLOCKING HTTPS/TLS (Most likely based on symptoms)")
+            logger.error("   - TCP connection succeeds")
+            logger.error("   - Connection drops during TLS handshake")
+            logger.error("   - Indicates deep packet inspection (DPI) is active")
+            logger.error("   - Solution: Ask network team to whitelist graph.microsoft.us")
+            logger.error("")
+            logger.error("2. Proxy configuration needed")
+            logger.error("   - Set HTTP_PROXY and HTTPS_PROXY environment variables")
+            logger.error("")
+            logger.error("3. SSL/TLS version or certificate issue")
+            logger.error("   - Less likely if TCP connects successfully")
+            logger.error("")
+            logger.error("=" * 70)
+            raise
+
+        except requests.exceptions.Timeout:
+            logger.error(f"✗ Request timeout after 30 seconds", exc_info=True)
+            raise
+
         except requests.exceptions.RequestException as e:
-            logger.error(f"Network error getting site ID: {type(e).__name__}: {e}", exc_info=True)
+            logger.error(f"✗ Network error getting site ID: {type(e).__name__}: {e}", exc_info=True)
             raise
 
     def _get_drive_id(self) -> str:
@@ -134,16 +308,24 @@ class GraphAPIClient:
         url = f"{self.graph_endpoint}/sites/{site_id}/drive"
 
         logger.info(f"Fetching drive ID from: {url}")
+
         try:
-            response = requests.get(url, headers=self._get_headers(), timeout=30)
-            logger.debug(f"Response status: {response.status_code}")
+            logger.debug(f"Sending GET request to: {url}")
+            response = self._session.get(url, headers=self._get_headers(), timeout=30)
+
+            logger.debug(f"Response received - Status: {response.status_code}")
             self._handle_response(response)
 
             self._drive_id = response.json()["id"]
-            logger.info(f"Retrieved drive ID: {self._drive_id}")
+            logger.info(f"✓ Retrieved drive ID: {self._drive_id}")
             return self._drive_id
+
+        except requests.exceptions.ConnectionError as e:
+            logger.error(f"✗ ConnectionError getting drive ID: {e}", exc_info=True)
+            raise
+
         except requests.exceptions.RequestException as e:
-            logger.error(f"Network error getting drive ID: {type(e).__name__}: {e}", exc_info=True)
+            logger.error(f"✗ Network error getting drive ID: {type(e).__name__}: {e}", exc_info=True)
             raise
 
     def list_folders(self, folder_path: str = "") -> List[Dict[str, Any]]:
@@ -169,7 +351,7 @@ class GraphAPIClient:
 
         logger.info(f"Fetching folders from: {url}")
         try:
-            response = requests.get(url, headers=self._get_headers(), timeout=30)
+            response = self._session.get(url, headers=self._get_headers(), timeout=30)
             logger.debug(f"Response status: {response.status_code}")
             self._handle_response(response)
 
@@ -213,7 +395,7 @@ class GraphAPIClient:
 
         logger.info(f"Fetching documents from: {url}")
         try:
-            response = requests.get(url, headers=self._get_headers(), timeout=30)
+            response = self._session.get(url, headers=self._get_headers(), timeout=30)
             logger.debug(f"Response status: {response.status_code}")
             self._handle_response(response)
 
@@ -255,7 +437,7 @@ class GraphAPIClient:
 
         logger.info(f"Fetching file content from: {url}")
         try:
-            response = requests.get(url, headers=self._get_headers(), timeout=60)
+            response = self._session.get(url, headers=self._get_headers(), timeout=60)
             logger.debug(f"Response status: {response.status_code}")
             self._handle_response(response)
 
@@ -294,7 +476,7 @@ class GraphAPIClient:
         headers["Content-Type"] = "application/octet-stream"
 
         try:
-            response = requests.put(url, headers=headers, data=content, timeout=120)
+            response = self._session.put(url, headers=headers, data=content, timeout=120)
             logger.debug(f"Response status: {response.status_code}")
             self._handle_response(response)
 
@@ -320,7 +502,7 @@ class GraphAPIClient:
 
         logger.info(f"Deleting from: {url}")
         try:
-            response = requests.delete(url, headers=self._get_headers(), timeout=30)
+            response = self._session.delete(url, headers=self._get_headers(), timeout=30)
             logger.debug(f"Response status: {response.status_code}")
             self._handle_response(response)
 
@@ -358,7 +540,7 @@ class GraphAPIClient:
         }
 
         try:
-            response = requests.post(url, headers=self._get_headers(), json=payload, timeout=30)
+            response = self._session.post(url, headers=self._get_headers(), json=payload, timeout=30)
             logger.debug(f"Response status: {response.status_code}")
             self._handle_response(response)
 
@@ -384,7 +566,7 @@ class GraphAPIClient:
 
         logger.info(f"Deleting folder from: {url}")
         try:
-            response = requests.delete(url, headers=self._get_headers(), timeout=30)
+            response = self._session.delete(url, headers=self._get_headers(), timeout=30)
             logger.debug(f"Response status: {response.status_code}")
             self._handle_response(response)
 

{mcp_sharepoint_us-2.0.14 → mcp_sharepoint_us-2.0.16}/src/mcp_sharepoint_us.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-sharepoint-us
-Version: 2.0.14
+Version: 2.0.16
 Summary: SharePoint MCP Server with Microsoft Graph API
 License: MIT
 Project-URL: Homepage, https://github.com/mdev26/mcp-sharepoint-us