mcp-sharepoint-us 2.0.13__tar.gz → 2.0.15__tar.gz

{mcp_sharepoint_us-2.0.13 → mcp_sharepoint_us-2.0.15}/PKG-INFO

@@ -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.13 → mcp_sharepoint_us-2.0.15}/pyproject.toml

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

{mcp_sharepoint_us-2.0.13 → mcp_sharepoint_us-2.0.15}/src/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_us-2.0.13 → mcp_sharepoint_us-2.0.15}/src/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_us-2.0.15/src/mcp_sharepoint/graph_api.py

@@ -0,0 +1,544 @@
+"""
+Microsoft Graph API implementation for SharePoint operations.
+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__)
+
+
+class GraphAPIClient:
+    """
+    Microsoft Graph API client for SharePoint operations.
+    Primary client for all SharePoint operations, especially in Azure Government Cloud
+    where SharePoint REST API may not support app-only authentication.
+    """
+
+    def __init__(self, site_url: str, token_callback):
+        """
+        Initialize Graph API client.
+
+        Args:
+            site_url: SharePoint site URL (e.g., https://tenant.sharepoint.us/sites/SiteName)
+            token_callback: Function that returns access token
+        """
+        self.site_url = site_url.rstrip("/")
+        self.token_callback = token_callback
+        self._site_id = None
+        self._drive_id = None  # Cache drive ID to avoid repeated API calls
+
+        # Determine Graph API endpoint based on cloud
+        if ".sharepoint.us" in site_url:
+            self.graph_endpoint = "https://graph.microsoft.us/v1.0"
+            logger.info("Using Microsoft Graph US Government endpoint")
+        else:
+            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'):
+            token = token_obj.accessToken
+        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",
+        }
+
+    def _handle_response(self, response: requests.Response) -> None:
+        """
+        Handle Graph API response and raise detailed errors if needed.
+
+        Graph API returns errors in format:
+        {
+          "error": {
+            "code": "itemNotFound",
+            "message": "The resource could not be found."
+          }
+        }
+        """
+        if response.ok:
+            return
+
+        try:
+            error_data = response.json()
+            if "error" in error_data:
+                error = error_data["error"]
+                code = error.get("code", "Unknown")
+                message = error.get("message", "Unknown error")
+                raise requests.HTTPError(
+                    f"Graph API error [{code}]: {message}",
+                    response=response
+                )
+        except (ValueError, KeyError):
+            # If we can't parse the error, fall back to standard handling
+            pass
+
+        self._handle_response(response)
+
+    def _get_site_id(self) -> str:
+        """
+        Get the site ID from the site URL.
+        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)
+        hostname = parsed.netloc
+        path = parsed.path.strip("/")
+
+        # For root site: https://tenant.sharepoint.us
+        if not path or path == "sites":
+            url = f"{self.graph_endpoint}/sites/{hostname}"
+        # For subsite: https://tenant.sharepoint.us/sites/SiteName
+        else:
+            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:
+            # 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}")
+            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:
+        """
+        Get the default document library drive ID.
+        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"
+
+        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
+
+        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]]:
+        """
+        List folders in the specified path.
+
+        Args:
+            folder_path: Relative path from document library root
+
+        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()
+
+        if folder_path:
+            # URL encode the path
+            encoded_path = quote(folder_path)
+            url = f"{self.graph_endpoint}/sites/{site_id}/drives/{drive_id}/root:/{encoded_path}:/children"
+        else:
+            url = f"{self.graph_endpoint}/sites/{site_id}/drives/{drive_id}/root/children"
+
+        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]]:
+        """
+        List documents in the specified folder.
+
+        Args:
+            folder_path: Relative path from document library root
+
+        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()
+
+        if folder_path:
+            encoded_path = quote(folder_path)
+            url = f"{self.graph_endpoint}/sites/{site_id}/drives/{drive_id}/root:/{encoded_path}:/children"
+        else:
+            url = f"{self.graph_endpoint}/sites/{site_id}/drives/{drive_id}/root/children"
+
+        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:
+        """
+        Get the content of a file.
+
+        Args:
+            file_path: Relative path to the file
+
+        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"
+
+        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
+        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]:
+        """
+        Upload a file to SharePoint.
+
+        Args:
+            folder_path: Destination folder path
+            file_name: Name of the file
+            content: File content as bytes
+
+        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()
+
+        if folder_path:
+            full_path = f"{folder_path}/{file_name}"
+        else:
+            full_path = file_name
+
+        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"
+
+        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"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:
+        """
+        Delete a file.
+
+        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}"
+
+        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"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]:
+        """
+        Create a new folder.
+
+        Args:
+            parent_path: Path to parent folder
+            folder_name: Name of the new folder
+
+        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()
+
+        if parent_path:
+            encoded_path = quote(parent_path)
+            url = f"{self.graph_endpoint}/sites/{site_id}/drives/{drive_id}/root:/{encoded_path}:/children"
+        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"
+        }
+
+        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"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:
+        """
+        Delete a folder.
+
+        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}"
+
+        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 → mcp_sharepoint_us-2.0.15}/src/mcp_sharepoint_us.egg-info/PKG-INFO

@@ -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.13/src/mcp_sharepoint/graph_api.py

@@ -1,328 +0,0 @@
-"""
-Microsoft Graph API implementation for SharePoint operations.
-Primary API for all SharePoint operations in Azure Government Cloud.
-"""
-import os
-import logging
-import asyncio
-from typing import Optional, Dict, Any, List
-from urllib.parse import urlparse, quote
-import requests
-
-logger = logging.getLogger(__name__)
-
-
-class GraphAPIClient:
-    """
-    Microsoft Graph API client for SharePoint operations.
-    Primary client for all SharePoint operations, especially in Azure Government Cloud
-    where SharePoint REST API may not support app-only authentication.
-    """
-
-    def __init__(self, site_url: str, token_callback):
-        """
-        Initialize Graph API client.
-
-        Args:
-            site_url: SharePoint site URL (e.g., https://tenant.sharepoint.us/sites/SiteName)
-            token_callback: Function that returns access token
-        """
-        self.site_url = site_url.rstrip("/")
-        self.token_callback = token_callback
-        self._site_id = None
-        self._drive_id = None  # Cache drive ID to avoid repeated API calls
-
-        # Determine Graph API endpoint based on cloud
-        if ".sharepoint.us" in site_url:
-            self.graph_endpoint = "https://graph.microsoft.us/v1.0"
-            logger.info("Using Microsoft Graph US Government endpoint")
-        else:
-            self.graph_endpoint = "https://graph.microsoft.com/v1.0"
-            logger.info("Using Microsoft Graph Commercial endpoint")
-
-    def _get_headers(self) -> Dict[str, str]:
-        """Get authorization headers with access token."""
-        token_obj = self.token_callback()
-        # Handle both TokenResponse objects and plain strings
-        if hasattr(token_obj, 'accessToken'):
-            token = token_obj.accessToken
-        else:
-            token = str(token_obj)
-
-        return {
-            "Authorization": f"Bearer {token}",
-            "Accept": "application/json",
-        }
-
-    def _handle_response(self, response: requests.Response) -> None:
-        """
-        Handle Graph API response and raise detailed errors if needed.
-
-        Graph API returns errors in format:
-        {
-          "error": {
-            "code": "itemNotFound",
-            "message": "The resource could not be found."
-          }
-        }
-        """
-        if response.ok:
-            return
-
-        try:
-            error_data = response.json()
-            if "error" in error_data:
-                error = error_data["error"]
-                code = error.get("code", "Unknown")
-                message = error.get("message", "Unknown error")
-                raise requests.HTTPError(
-                    f"Graph API error [{code}]: {message}",
-                    response=response
-                )
-        except (ValueError, KeyError):
-            # If we can't parse the error, fall back to standard handling
-            pass
-
-        self._handle_response(response)
-
-    def _get_site_id(self) -> str:
-        """
-        Get the site ID from the site URL.
-        Caches the result for reuse.
-        """
-        if self._site_id:
-            return self._site_id
-
-        parsed = urlparse(self.site_url)
-        hostname = parsed.netloc
-        path = parsed.path.strip("/")
-
-        # For root site: https://tenant.sharepoint.us
-        if not path or path == "sites":
-            url = f"{self.graph_endpoint}/sites/{hostname}"
-        # For subsite: https://tenant.sharepoint.us/sites/SiteName
-        else:
-            url = f"{self.graph_endpoint}/sites/{hostname}:/{path}"
-
-        response = requests.get(url, headers=self._get_headers())
-        self._handle_response(response)
-
-        self._site_id = response.json()["id"]
-        logger.info(f"Retrieved site ID: {self._site_id}")
-        return self._site_id
-
-    def _get_drive_id(self) -> str:
-        """
-        Get the default document library drive ID.
-        Caches the result for reuse.
-        """
-        if 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)
-
-        self._drive_id = response.json()["id"]
-        logger.info(f"Retrieved drive ID: {self._drive_id}")
-        return self._drive_id
-
-    def list_folders(self, folder_path: str = "") -> List[Dict[str, Any]]:
-        """
-        List folders in the specified path.
-
-        Args:
-            folder_path: Relative path from document library root
-
-        Returns:
-            List of folder objects with name, id, webUrl
-        """
-        site_id = self._get_site_id()
-        drive_id = self._get_drive_id()
-
-        if folder_path:
-            # URL encode the path
-            encoded_path = quote(folder_path)
-            url = f"{self.graph_endpoint}/sites/{site_id}/drives/{drive_id}/root:/{encoded_path}:/children"
-        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
-
-    def list_documents(self, folder_path: str = "") -> List[Dict[str, Any]]:
-        """
-        List documents in the specified folder.
-
-        Args:
-            folder_path: Relative path from document library root
-
-        Returns:
-            List of file objects with name, id, size, webUrl
-        """
-        site_id = self._get_site_id()
-        drive_id = self._get_drive_id()
-
-        if folder_path:
-            encoded_path = quote(folder_path)
-            url = f"{self.graph_endpoint}/sites/{site_id}/drives/{drive_id}/root:/{encoded_path}:/children"
-        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
-
-    def get_file_content(self, file_path: str) -> bytes:
-        """
-        Get the content of a file.
-
-        Args:
-            file_path: Relative path to the file
-
-        Returns:
-            File content as bytes
-        """
-        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"Retrieved content for '{file_path}' ({len(response.content)} bytes)")
-        return response.content
-
-    def upload_file(self, folder_path: str, file_name: str, content: bytes) -> Dict[str, Any]:
-        """
-        Upload a file to SharePoint.
-
-        Args:
-            folder_path: Destination folder path
-            file_name: Name of the file
-            content: File content as bytes
-
-        Returns:
-            File metadata
-        """
-        site_id = self._get_site_id()
-        drive_id = self._get_drive_id()
-
-        if folder_path:
-            full_path = f"{folder_path}/{file_name}"
-        else:
-            full_path = file_name
-
-        encoded_path = quote(full_path)
-        url = f"{self.graph_endpoint}/sites/{site_id}/drives/{drive_id}/root:/{encoded_path}:/content"
-
-        headers = self._get_headers()
-        headers["Content-Type"] = "application/octet-stream"
-
-        response = requests.put(url, headers=headers, data=content)
-        self._handle_response(response)
-
-        logger.info(f"Uploaded '{file_name}' to '{folder_path}'")
-        return response.json()
-
-    def delete_file(self, file_path: str) -> None:
-        """
-        Delete a file.
-
-        Args:
-            file_path: Relative path to the file
-        """
-        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"Deleted '{file_path}'")
-
-    def create_folder(self, parent_path: str, folder_name: str) -> Dict[str, Any]:
-        """
-        Create a new folder.
-
-        Args:
-            parent_path: Path to parent folder
-            folder_name: Name of the new folder
-
-        Returns:
-            Folder metadata
-        """
-        site_id = self._get_site_id()
-        drive_id = self._get_drive_id()
-
-        if parent_path:
-            encoded_path = quote(parent_path)
-            url = f"{self.graph_endpoint}/sites/{site_id}/drives/{drive_id}/root:/{encoded_path}:/children"
-        else:
-            url = f"{self.graph_endpoint}/sites/{site_id}/drives/{drive_id}/root/children"
-
-        payload = {
-            "name": folder_name,
-            "folder": {},
-            "@microsoft.graph.conflictBehavior": "fail"
-        }
-
-        response = requests.post(url, headers=self._get_headers(), json=payload)
-        self._handle_response(response)
-
-        logger.info(f"Created folder '{folder_name}' in '{parent_path}'")
-        return response.json()
-
-    def delete_folder(self, folder_path: str) -> None:
-        """
-        Delete a folder.
-
-        Args:
-            folder_path: Relative path to the folder
-        """
-        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}'")