mcp-sharepoint-us 2.0.13__py3-none-any.whl → 2.0.15__py3-none-any.whl

mcp_sharepoint/__init__.py

@@ -35,6 +35,7 @@ def ensure_context(func):
         global graph_client, authenticator
         if graph_client is None:
             try:
+                logger.info("Initializing Graph API client...")
                 from .auth import SharePointAuthenticator
 
                 # Get credentials
@@ -44,6 +45,11 @@ def ensure_context(func):
                 tenant_id = os.getenv("SHP_TENANT_ID")
                 cloud = "government" if ".sharepoint.us" in site_url else "commercial"
 
+                logger.info(f"Site URL: {site_url}")
+                logger.info(f"Tenant ID: {tenant_id}")
+                logger.info(f"Client ID: {client_id}")
+                logger.info(f"Cloud: {cloud}")
+
                 # Create shared authenticator
                 authenticator = SharePointAuthenticator(
                     site_url=site_url,
@@ -52,11 +58,15 @@ def ensure_context(func):
                     tenant_id=tenant_id,
                     cloud=cloud
                 )
+                logger.info("Authenticator created successfully")
 
                 # Create Graph API client with direct token access
                 def get_token():
                     """Get access token for Graph API"""
-                    return authenticator.get_access_token()
+                    logger.debug("Token callback invoked")
+                    token = authenticator.get_access_token()
+                    logger.debug(f"Token acquired (length: {len(token)})")
+                    return token
 
                 graph_client = GraphAPIClient(
                     site_url=site_url,
@@ -65,7 +75,7 @@ def ensure_context(func):
                 logger.info("Graph API client initialized successfully")
 
             except Exception as e:
-                logger.error(f"Failed to initialize Graph API client: {e}")
+                logger.error(f"Failed to initialize Graph API client: {e}", exc_info=True)
                 raise RuntimeError(
                     f"Graph API authentication failed: {e}. "
                     "Please check your environment variables and ensure:\n"
@@ -321,28 +331,42 @@ async def call_tool(name: str, arguments: dict) -> list[TextContent]:
 
 
 async def test_connection() -> list[TextContent]:
-    """Test SharePoint connection"""
+    """Test SharePoint connection using Microsoft Graph API"""
     try:
-        web = ctx.web.get().execute_query()
-        auth_method = os.getenv("SHP_AUTH_METHOD", "msal")
-        
+        logger.info("Testing Graph API connection...")
+
+        # Try to get site ID and drive ID
+        site_id = await asyncio.to_thread(graph_client._get_site_id)
+        drive_id = await asyncio.to_thread(graph_client._get_drive_id)
+
+        auth_method = "msal (Microsoft Graph API)"
+
+        logger.info(f"✓ Connection test successful - Site ID: {site_id}, Drive ID: {drive_id}")
+
         return [TextContent(
             type="text",
-            text=f"✓ Successfully connected to SharePoint!\n\n"
-                 f"Site Title: {web.title}\n"
-                 f"Site URL: {web.url}\n"
-                 f"Authentication Method: {auth_method.upper()}\n"
+            text=f"✓ Successfully connected to SharePoint via Microsoft Graph API!\n\n"
+                 f"Site URL: {graph_client.site_url}\n"
+                 f"Graph Endpoint: {graph_client.graph_endpoint}\n"
+                 f"Site ID: {site_id}\n"
+                 f"Drive ID: {drive_id}\n"
+                 f"Authentication Method: {auth_method}\n"
                  f"Tenant ID: {os.getenv('SHP_TENANT_ID')}\n\n"
-                 f"Connection is working correctly with modern Azure AD authentication."
+                 f"Connection is working correctly with Microsoft Graph API."
         )]
     except Exception as e:
+        logger.error(f"✗ Connection test failed: {str(e)}", exc_info=True)
         return [TextContent(
             type="text",
             text=f"✗ Connection failed: {str(e)}\n\n"
                  f"This usually means:\n"
                  f"1. Your credentials are incorrect\n"
-                 f"2. Your app doesn't have proper SharePoint permissions\n"
-                 f"3. You're using legacy auth on a new tenant (set SHP_AUTH_METHOD=msal)"
+                 f"2. Your app doesn't have proper Microsoft Graph permissions\n"
+                 f"3. Network connectivity issues\n"
+                 f"4. Azure AD app registration is missing required permissions:\n"
+                 f"   - Sites.Read.All\n"
+                 f"   - Files.ReadWrite.All\n\n"
+                 f"Check the logs for more details."
         )]
 
 

mcp_sharepoint/auth.py

@@ -226,16 +226,22 @@ class SharePointAuthenticator:
 
         now = int(time.time())
         if self._access_token and now < (self._access_token_exp - 60):
+            logger.debug("Using cached access token")
             return self._access_token
 
+        logger.info(f"Acquiring new access token from {self._authority_url}")
+        logger.debug(f"Scopes: {self._scopes}")
+
         last_err = None
         for attempt in range(1, 6):  # 5 attempts
             try:
+                logger.debug(f"Token acquisition attempt {attempt}/5")
                 result = self._msal_app.acquire_token_for_client(scopes=self._scopes)
 
                 if "access_token" not in result:
                     error_desc = result.get("error_description", "Unknown error")
                     error = result.get("error", "Unknown")
+                    logger.error(f"Token acquisition failed: {error} - {error_desc}")
                     raise ValueError(
                         f"Failed to acquire token: {error} - {error_desc}\n"
                         f"Authority: {self._authority_url}\n"
@@ -249,11 +255,13 @@ class SharePointAuthenticator:
                 self._access_token = token
                 self._access_token_exp = int(time.time()) + expires_in
 
-                logger.info(f"Successfully acquired Graph API token")
+                logger.info(f"Successfully acquired Graph API token (expires in {expires_in}s)")
+                logger.debug(f"Token length: {len(token)}, starts with: {token[:20]}...")
                 return token
 
             except Exception as e:
                 last_err = e
+                logger.error(f"Token acquisition attempt {attempt}/5 failed: {type(e).__name__}: {e}")
                 # Exponential backoff with jitter
                 sleep_s = min(8.0, (2 ** (attempt - 1)) * 0.5) + random.random() * 0.25
                 logger.warning(

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,8 +44,113 @@ 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...")
+                    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 handshake failed: {e}")
+                        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...")
         token_obj = self.token_callback()
         # Handle both TokenResponse objects and plain strings
         if hasattr(token_obj, 'accessToken'):
@@ -49,6 +158,8 @@ class GraphAPIClient:
         else:
             token = str(token_obj)
 
+        logger.debug(f"Token acquired for headers (length: {len(token)}, starts with: {token[:20]}...)")
+
         return {
             "Authorization": f"Bearer {token}",
             "Accept": "application/json",
@@ -91,6 +202,7 @@ class GraphAPIClient:
         Caches the result for reuse.
         """
         if self._site_id:
+            logger.debug(f"Using cached site ID: {self._site_id}")
             return self._site_id
 
         parsed = urlparse(self.site_url)
@@ -104,12 +216,52 @@ class GraphAPIClient:
         else:
             url = f"{self.graph_endpoint}/sites/{hostname}:/{path}"
 
-        response = requests.get(url, headers=self._get_headers())
-        self._handle_response(response)
+        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:
+            # 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)
 
-        self._site_id = response.json()["id"]
-        logger.info(f"Retrieved site ID: {self._site_id}")
-        return self._site_id
+            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}")
+            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...")
+
+            # Run diagnostics to help identify the issue
+            self._diagnose_connectivity(url)
+
+            logger.error("\nPossible causes:")
+            logger.error("1. Firewall is blocking graph.microsoft.us")
+            logger.error("2. Proxy configuration needed")
+            logger.error("3. SSL/TLS version mismatch")
+            logger.error("4. Network instability")
+            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)
+            raise
 
     def _get_drive_id(self) -> str:
         """
@@ -117,17 +269,32 @@ class GraphAPIClient:
         Caches the result for reuse.
         """
         if self._drive_id:
+            logger.debug(f"Using cached drive ID: {self._drive_id}")
             return self._drive_id
 
         site_id = self._get_site_id()
         url = f"{self.graph_endpoint}/sites/{site_id}/drive"
 
-        response = requests.get(url, headers=self._get_headers())
-        self._handle_response(response)
+        logger.info(f"Fetching drive ID from: {url}")
+
+        try:
+            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}")
-        return self._drive_id
+            self._drive_id = response.json()["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)
+            raise
 
     def list_folders(self, folder_path: str = "") -> List[Dict[str, Any]]:
         """
@@ -139,6 +306,7 @@ class GraphAPIClient:
         Returns:
             List of folder objects with name, id, webUrl
         """
+        logger.info(f"Listing folders in '{folder_path}'")
         site_id = self._get_site_id()
         drive_id = self._get_drive_id()
 
@@ -149,23 +317,29 @@ class GraphAPIClient:
         else:
             url = f"{self.graph_endpoint}/sites/{site_id}/drives/{drive_id}/root/children"
 
-        response = requests.get(url, headers=self._get_headers())
-        self._handle_response(response)
-
-        items = response.json().get("value", [])
-        # Filter to only folders
-        folders = [
-            {
-                "name": item["name"],
-                "id": item["id"],
-                "webUrl": item.get("webUrl", ""),
-            }
-            for item in items
-            if "folder" in item
-        ]
-
-        logger.info(f"Found {len(folders)} folders in '{folder_path}'")
-        return folders
+        logger.info(f"Fetching folders from: {url}")
+        try:
+            response = self._session.get(url, headers=self._get_headers(), timeout=30)
+            logger.debug(f"Response status: {response.status_code}")
+            self._handle_response(response)
+
+            items = response.json().get("value", [])
+            # Filter to only folders
+            folders = [
+                {
+                    "name": item["name"],
+                    "id": item["id"],
+                    "webUrl": item.get("webUrl", ""),
+                }
+                for item in items
+                if "folder" in item
+            ]
+
+            logger.info(f"Found {len(folders)} folders in '{folder_path}'")
+            return folders
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Network error listing folders: {type(e).__name__}: {e}", exc_info=True)
+            raise
 
     def list_documents(self, folder_path: str = "") -> List[Dict[str, Any]]:
         """
@@ -177,6 +351,7 @@ class GraphAPIClient:
         Returns:
             List of file objects with name, id, size, webUrl
         """
+        logger.info(f"Listing documents in '{folder_path}'")
         site_id = self._get_site_id()
         drive_id = self._get_drive_id()
 
@@ -186,24 +361,30 @@ class GraphAPIClient:
         else:
             url = f"{self.graph_endpoint}/sites/{site_id}/drives/{drive_id}/root/children"
 
-        response = requests.get(url, headers=self._get_headers())
-        self._handle_response(response)
-
-        items = response.json().get("value", [])
-        # Filter to only files
-        files = [
-            {
-                "name": item["name"],
-                "id": item["id"],
-                "size": item.get("size", 0),
-                "webUrl": item.get("webUrl", ""),
-            }
-            for item in items
-            if "file" in item
-        ]
-
-        logger.info(f"Found {len(files)} files in '{folder_path}'")
-        return files
+        logger.info(f"Fetching documents from: {url}")
+        try:
+            response = self._session.get(url, headers=self._get_headers(), timeout=30)
+            logger.debug(f"Response status: {response.status_code}")
+            self._handle_response(response)
+
+            items = response.json().get("value", [])
+            # Filter to only files
+            files = [
+                {
+                    "name": item["name"],
+                    "id": item["id"],
+                    "size": item.get("size", 0),
+                    "webUrl": item.get("webUrl", ""),
+                }
+                for item in items
+                if "file" in item
+            ]
+
+            logger.info(f"Found {len(files)} files in '{folder_path}'")
+            return files
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Network error listing documents: {type(e).__name__}: {e}", exc_info=True)
+            raise
 
     def get_file_content(self, file_path: str) -> bytes:
         """
@@ -215,17 +396,24 @@ class GraphAPIClient:
         Returns:
             File content as bytes
         """
+        logger.info(f"Getting content for file '{file_path}'")
         site_id = self._get_site_id()
         drive_id = self._get_drive_id()
 
         encoded_path = quote(file_path)
         url = f"{self.graph_endpoint}/sites/{site_id}/drives/{drive_id}/root:/{encoded_path}:/content"
 
-        response = requests.get(url, headers=self._get_headers())
-        self._handle_response(response)
+        logger.info(f"Fetching file content from: {url}")
+        try:
+            response = self._session.get(url, headers=self._get_headers(), timeout=60)
+            logger.debug(f"Response status: {response.status_code}")
+            self._handle_response(response)
 
-        logger.info(f"Retrieved content for '{file_path}' ({len(response.content)} bytes)")
-        return response.content
+            logger.info(f"Retrieved content for '{file_path}' ({len(response.content)} bytes)")
+            return response.content
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Network error getting file content: {type(e).__name__}: {e}", exc_info=True)
+            raise
 
     def upload_file(self, folder_path: str, file_name: str, content: bytes) -> Dict[str, Any]:
         """
@@ -239,6 +427,7 @@ class GraphAPIClient:
         Returns:
             File metadata
         """
+        logger.info(f"Uploading file '{file_name}' to '{folder_path}' ({len(content)} bytes)")
         site_id = self._get_site_id()
         drive_id = self._get_drive_id()
 
@@ -250,14 +439,20 @@ class GraphAPIClient:
         encoded_path = quote(full_path)
         url = f"{self.graph_endpoint}/sites/{site_id}/drives/{drive_id}/root:/{encoded_path}:/content"
 
+        logger.info(f"Uploading to: {url}")
         headers = self._get_headers()
         headers["Content-Type"] = "application/octet-stream"
 
-        response = requests.put(url, headers=headers, data=content)
-        self._handle_response(response)
+        try:
+            response = self._session.put(url, headers=headers, data=content, timeout=120)
+            logger.debug(f"Response status: {response.status_code}")
+            self._handle_response(response)
 
-        logger.info(f"Uploaded '{file_name}' to '{folder_path}'")
-        return response.json()
+            logger.info(f"Successfully uploaded '{file_name}' to '{folder_path}'")
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Network error uploading file: {type(e).__name__}: {e}", exc_info=True)
+            raise
 
     def delete_file(self, file_path: str) -> None:
         """
@@ -266,16 +461,23 @@ class GraphAPIClient:
         Args:
             file_path: Relative path to the file
         """
+        logger.info(f"Deleting file '{file_path}'")
         site_id = self._get_site_id()
         drive_id = self._get_drive_id()
 
         encoded_path = quote(file_path)
         url = f"{self.graph_endpoint}/sites/{site_id}/drives/{drive_id}/root:/{encoded_path}"
 
-        response = requests.delete(url, headers=self._get_headers())
-        self._handle_response(response)
+        logger.info(f"Deleting from: {url}")
+        try:
+            response = self._session.delete(url, headers=self._get_headers(), timeout=30)
+            logger.debug(f"Response status: {response.status_code}")
+            self._handle_response(response)
 
-        logger.info(f"Deleted '{file_path}'")
+            logger.info(f"Successfully deleted '{file_path}'")
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Network error deleting file: {type(e).__name__}: {e}", exc_info=True)
+            raise
 
     def create_folder(self, parent_path: str, folder_name: str) -> Dict[str, Any]:
         """
@@ -288,6 +490,7 @@ class GraphAPIClient:
         Returns:
             Folder metadata
         """
+        logger.info(f"Creating folder '{folder_name}' in '{parent_path}'")
         site_id = self._get_site_id()
         drive_id = self._get_drive_id()
 
@@ -297,17 +500,23 @@ class GraphAPIClient:
         else:
             url = f"{self.graph_endpoint}/sites/{site_id}/drives/{drive_id}/root/children"
 
+        logger.info(f"Creating folder at: {url}")
         payload = {
             "name": folder_name,
             "folder": {},
             "@microsoft.graph.conflictBehavior": "fail"
         }
 
-        response = requests.post(url, headers=self._get_headers(), json=payload)
-        self._handle_response(response)
+        try:
+            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)
 
-        logger.info(f"Created folder '{folder_name}' in '{parent_path}'")
-        return response.json()
+            logger.info(f"Successfully created folder '{folder_name}' in '{parent_path}'")
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Network error creating folder: {type(e).__name__}: {e}", exc_info=True)
+            raise
 
     def delete_folder(self, folder_path: str) -> None:
         """
@@ -316,13 +525,20 @@ class GraphAPIClient:
         Args:
             folder_path: Relative path to the folder
         """
+        logger.info(f"Deleting folder '{folder_path}'")
         site_id = self._get_site_id()
         drive_id = self._get_drive_id()
 
         encoded_path = quote(folder_path)
         url = f"{self.graph_endpoint}/sites/{site_id}/drives/{drive_id}/root:/{encoded_path}"
 
-        response = requests.delete(url, headers=self._get_headers())
-        self._handle_response(response)
-
-        logger.info(f"Deleted folder '{folder_path}'")
+        logger.info(f"Deleting folder from: {url}")
+        try:
+            response = self._session.delete(url, headers=self._get_headers(), timeout=30)
+            logger.debug(f"Response status: {response.status_code}")
+            self._handle_response(response)
+
+            logger.info(f"Successfully deleted folder '{folder_path}'")
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Network error deleting folder: {type(e).__name__}: {e}", exc_info=True)
+            raise

{mcp_sharepoint_us-2.0.13.dist-info → mcp_sharepoint_us-2.0.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-sharepoint-us
-Version: 2.0.13
+Version: 2.0.15
 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.15.dist-info/RECORD

@@ -0,0 +1,10 @@
+mcp_sharepoint/__init__.py,sha256=sSJtlX91mBQ4fM12R8XK7Vrkkr3YPJqriE8LZP157vM,20969
+mcp_sharepoint/__main__.py,sha256=4iVDdDZx4rQ4Zo-x0RaCrT-NKeGObIz_ks3YF8di2nA,132
+mcp_sharepoint/auth.py,sha256=fwOCsg1pv0cN26hNlsHhJhGckeDkJCiXZrMmiBn9jf4,18156
+mcp_sharepoint/graph_api.py,sha256=csVdyg0W9-WnDjP-rACPoym1LF8SLjpJFjolaYaCwpU,21181
+mcp_sharepoint_us-2.0.15.dist-info/licenses/LICENSE,sha256=SRM8juGH4GjIqnl5rrp-P-S5mW5h2mINOPx5-wOZG6s,1112
+mcp_sharepoint_us-2.0.15.dist-info/METADATA,sha256=R3i9IT0YzEyfNIKZ4jmFe1q6WSA_ybHoN3-Oe-TdeTQ,11402
+mcp_sharepoint_us-2.0.15.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mcp_sharepoint_us-2.0.15.dist-info/entry_points.txt,sha256=UZOa_7OLI41rmsErbvnSz9RahPMGQVcqZUFMphOcjbY,57
+mcp_sharepoint_us-2.0.15.dist-info/top_level.txt,sha256=R6mRoWe61lz4kUSKGV6S2XVbE7825xfC_J-ouZIYpuo,15
+mcp_sharepoint_us-2.0.15.dist-info/RECORD,,

mcp_sharepoint_us-2.0.13.dist-info/RECORD

@@ -1,10 +0,0 @@
-mcp_sharepoint/__init__.py,sha256=318-XBsPcTt2EH_B9j-ym_GFs91_0Kb-0WiLKfEV-L0,19744
-mcp_sharepoint/__main__.py,sha256=4iVDdDZx4rQ4Zo-x0RaCrT-NKeGObIz_ks3YF8di2nA,132
-mcp_sharepoint/auth.py,sha256=03p8ylIkrlNoVuVSJ96nnqUd8n7QnwWXWXkkV7y01AU,17598
-mcp_sharepoint/graph_api.py,sha256=y3Q5OHkitAsp7QN1PFIf_sh7g5DShLEfWUlHzIHeS24,10571
-mcp_sharepoint_us-2.0.13.dist-info/licenses/LICENSE,sha256=SRM8juGH4GjIqnl5rrp-P-S5mW5h2mINOPx5-wOZG6s,1112
-mcp_sharepoint_us-2.0.13.dist-info/METADATA,sha256=YNzf3j597kLjomxk9NDhQSHVTc41XGWx-vzVnnFWQHg,11402
-mcp_sharepoint_us-2.0.13.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-mcp_sharepoint_us-2.0.13.dist-info/entry_points.txt,sha256=UZOa_7OLI41rmsErbvnSz9RahPMGQVcqZUFMphOcjbY,57
-mcp_sharepoint_us-2.0.13.dist-info/top_level.txt,sha256=R6mRoWe61lz4kUSKGV6S2XVbE7825xfC_J-ouZIYpuo,15
-mcp_sharepoint_us-2.0.13.dist-info/RECORD,,