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

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: mcp-sharepoint-us
-Version: 2.0.11
-Summary: SharePoint MCP Server with Modern Azure AD Authentication
+Version: 2.0.13
+Summary: SharePoint MCP Server with Microsoft Graph API
 License: MIT
 Project-URL: Homepage, https://github.com/mdev26/mcp-sharepoint-us
 Project-URL: Repository, https://github.com/mdev26/mcp-sharepoint-us
@@ -22,6 +22,7 @@ Requires-Dist: office365-rest-python-client>=2.5.0
 Requires-Dist: msal>=1.24.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: pydantic>=2.0.0
+Requires-Dist: requests>=2.31.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"

{mcp_sharepoint_us-2.0.11 → mcp_sharepoint_us-2.0.13}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mcp-sharepoint-us"
-version = "2.0.11"
-description = "SharePoint MCP Server with Modern Azure AD Authentication"
+version = "2.0.13"
+description = "SharePoint MCP Server with Microsoft Graph API"
 readme = "README.md"
 requires-python = ">=3.10"
 license = { text = "MIT" }
@@ -26,6 +26,7 @@ dependencies = [
     "msal>=1.24.0",
     "python-dotenv>=1.0.0",
     "pydantic>=2.0.0",
+    "requests>=2.31.0",
 ]
 
 [project.optional-dependencies]

{mcp_sharepoint_us-2.0.11 → mcp_sharepoint_us-2.0.13}/src/mcp_sharepoint/__init__.py

@@ -14,11 +14,7 @@ from mcp.types import Resource, Tool, TextContent, ImageContent, EmbeddedResourc
 from pydantic import AnyUrl
 import mcp.server.stdio
 
-from office365.sharepoint.files.file import File
-from office365.sharepoint.folders.folder import Folder
-from office365.sharepoint.client_context import ClientContext
-
-from .auth import create_sharepoint_context
+from .graph_api import GraphAPIClient
 
 # Setup logging
 logging.basicConfig(level=logging.INFO)
@@ -27,27 +23,55 @@ logger = logging.getLogger(__name__)
 # Initialize MCP server
 app = Server("mcp-sharepoint")
 
-# Global SharePoint context
-ctx: Optional[ClientContext] = None
+# Global Graph API client and authenticator
+graph_client: Optional[GraphAPIClient] = None
+authenticator = None
 
 
 def ensure_context(func):
-    """Decorator to ensure SharePoint context is available"""
+    """Decorator to ensure Graph API client is available"""
     @wraps(func)
     async def wrapper(*args, **kwargs):
-        global ctx
-        if ctx is None:
+        global graph_client, authenticator
+        if graph_client is None:
             try:
-                ctx = create_sharepoint_context()
-                logger.info("SharePoint context initialized successfully")
+                from .auth import SharePointAuthenticator
+
+                # Get credentials
+                site_url = os.getenv("SHP_SITE_URL")
+                client_id = os.getenv("SHP_ID_APP")
+                client_secret = os.getenv("SHP_ID_APP_SECRET")
+                tenant_id = os.getenv("SHP_TENANT_ID")
+                cloud = "government" if ".sharepoint.us" in site_url else "commercial"
+
+                # Create shared authenticator
+                authenticator = SharePointAuthenticator(
+                    site_url=site_url,
+                    client_id=client_id,
+                    client_secret=client_secret,
+                    tenant_id=tenant_id,
+                    cloud=cloud
+                )
+
+                # Create Graph API client with direct token access
+                def get_token():
+                    """Get access token for Graph API"""
+                    return authenticator.get_access_token()
+
+                graph_client = GraphAPIClient(
+                    site_url=site_url,
+                    token_callback=get_token
+                )
+                logger.info("Graph API client initialized successfully")
+
             except Exception as e:
-                logger.error(f"Failed to initialize SharePoint context: {e}")
+                logger.error(f"Failed to initialize Graph API client: {e}")
                 raise RuntimeError(
-                    f"SharePoint authentication failed: {e}. "
+                    f"Graph API authentication failed: {e}. "
                     "Please check your environment variables and ensure:\n"
                     "1. SHP_TENANT_ID is set correctly\n"
-                    "2. Your Azure AD app has the correct API permissions\n"
-                    "3. If using a new tenant, make sure you're using modern auth (MSAL)"
+                    "2. Your Azure AD app has Microsoft Graph API permissions\n"
+                    "3. The app registration has 'Sites.Read.All' and 'Files.ReadWrite.All' permissions"
                 )
         return await func(*args, **kwargs)
     return wrapper
@@ -323,60 +347,48 @@ async def test_connection() -> list[TextContent]:
 
 
 async def list_folders(folder_path: str = "") -> list[TextContent]:
-    """List folders in specified path"""
+    """List folders in specified path using Microsoft Graph API"""
+    doc_lib = get_document_library_path()
+    full_path = f"{doc_lib}/{folder_path}" if folder_path else doc_lib
+
     try:
-        doc_lib = get_document_library_path()
-        full_path = f"{doc_lib}/{folder_path}" if folder_path else doc_lib
-        
-        folder = ctx.web.get_folder_by_server_relative_path(full_path)
-        folders = folder.folders.get().execute_query()
-        
-        folder_list = []
-        for f in folders:
-            folder_list.append(f"📁 {f.name}")
-        
+        # Use Graph API directly
+        folders = await asyncio.to_thread(graph_client.list_folders, folder_path)
+        folder_list = [f"📁 {f['name']}" for f in folders]
+
         result = f"Folders in '{full_path}':\n\n" + "\n".join(folder_list) if folder_list else f"No folders found in '{full_path}'"
-        
         return [TextContent(type="text", text=result)]
-        
+
     except Exception as e:
         return [TextContent(type="text", text=f"Error listing folders: {str(e)}")]
 
 
 async def list_documents(folder_path: str = "") -> list[TextContent]:
-    """List documents in specified folder"""
+    """List documents in specified folder using Microsoft Graph API"""
+    doc_lib = get_document_library_path()
+    full_path = f"{doc_lib}/{folder_path}" if folder_path else doc_lib
+
     try:
-        doc_lib = get_document_library_path()
-        full_path = f"{doc_lib}/{folder_path}" if folder_path else doc_lib
-        
-        folder = ctx.web.get_folder_by_server_relative_path(full_path)
-        files = folder.files.get().execute_query()
-        
+        # Use Graph API directly
+        files = await asyncio.to_thread(graph_client.list_documents, folder_path)
+
         file_list = []
         for f in files:
-            size_kb = f.length / 1024
-            file_list.append(f"📄 {f.name} ({size_kb:.2f} KB)")
-        
+            size_kb = f['size'] / 1024
+            file_list.append(f"📄 {f['name']} ({size_kb:.2f} KB)")
+
         result = f"Documents in '{full_path}':\n\n" + "\n".join(file_list) if file_list else f"No documents found in '{full_path}'"
-        
         return [TextContent(type="text", text=result)]
-        
+
     except Exception as e:
         return [TextContent(type="text", text=f"Error listing documents: {str(e)}")]
 
 
 async def get_document_content(file_path: str) -> list[TextContent]:
-    """Get document content"""
+    """Get document content using Microsoft Graph API"""
     try:
-        doc_lib = get_document_library_path()
-        full_path = f"{doc_lib}/{file_path}"
-
-        def _read_bytes():
-            sp_file = ctx.web.get_file_by_server_relative_path(full_path)
-            # IMPORTANT: execute the request
-            return sp_file.read().execute_query()
-
-        content = await asyncio.to_thread(_read_bytes)
+        # Use Graph API to get file content
+        content = await asyncio.to_thread(graph_client.get_file_content, file_path)
 
         ext = os.path.splitext(file_path)[1].lower()
         text_extensions = {'.txt', '.md', '.json', '.xml', '.html', '.csv', '.log'}
@@ -401,141 +413,127 @@ async def get_document_content(file_path: str) -> list[TextContent]:
 
 
 async def upload_document(folder_path: str, file_name: str, content: str, is_binary: bool = False) -> list[TextContent]:
-    """Upload a document"""
+    """Upload a document using Microsoft Graph API"""
     try:
-        doc_lib = get_document_library_path()
-        full_path = f"{doc_lib}/{folder_path}" if folder_path else doc_lib
-        
-        folder = ctx.web.get_folder_by_server_relative_path(full_path)
-        
         if is_binary:
             file_content = base64.b64decode(content)
         else:
             file_content = content.encode('utf-8')
-        
-        uploaded_file = folder.upload_file(file_name, file_content).execute_query()
-        
+
+        # Use Graph API to upload file
+        result = await asyncio.to_thread(
+            graph_client.upload_file,
+            folder_path,
+            file_name,
+            file_content
+        )
+
         return [TextContent(
             type="text",
-            text=f"✓ Successfully uploaded '{file_name}' to '{full_path}'"
+            text=f"✓ Successfully uploaded '{file_name}' to '{folder_path or 'root'}'"
         )]
-        
+
     except Exception as e:
         return [TextContent(type="text", text=f"Error uploading document: {str(e)}")]
 
 
 async def update_document(file_path: str, content: str, is_binary: bool = False) -> list[TextContent]:
-    """Update a document"""
+    """Update a document using Microsoft Graph API"""
     try:
-        doc_lib = get_document_library_path()
-        full_path = f"{doc_lib}/{file_path}"
-        
         if is_binary:
             file_content = base64.b64decode(content)
         else:
             file_content = content.encode('utf-8')
-        
-        file = ctx.web.get_file_by_server_relative_path(full_path)
-        file.write(file_content).execute_query()
-        
+
+        # Split file_path into folder and filename
+        folder_path = os.path.dirname(file_path)
+        file_name = os.path.basename(file_path)
+
+        # Use Graph API to upload/update file (PUT overwrites)
+        await asyncio.to_thread(
+            graph_client.upload_file,
+            folder_path,
+            file_name,
+            file_content
+        )
+
         return [TextContent(
             type="text",
             text=f"✓ Successfully updated '{file_path}'"
         )]
-        
+
     except Exception as e:
         return [TextContent(type="text", text=f"Error updating document: {str(e)}")]
 
 
 async def delete_document(file_path: str) -> list[TextContent]:
-    """Delete a document"""
+    """Delete a document using Microsoft Graph API"""
     try:
-        doc_lib = get_document_library_path()
-        full_path = f"{doc_lib}/{file_path}"
-        
-        file = ctx.web.get_file_by_server_relative_path(full_path)
-        file.delete_object().execute_query()
-        
+        # Use Graph API to delete file
+        await asyncio.to_thread(graph_client.delete_file, file_path)
+
         return [TextContent(
             type="text",
             text=f"✓ Successfully deleted '{file_path}'"
         )]
-        
+
     except Exception as e:
         return [TextContent(type="text", text=f"Error deleting document: {str(e)}")]
 
 
 async def create_folder(folder_path: str, folder_name: str) -> list[TextContent]:
-    """Create a folder"""
+    """Create a folder using Microsoft Graph API"""
     try:
-        doc_lib = get_document_library_path()
-        full_path = f"{doc_lib}/{folder_path}" if folder_path else doc_lib
-        
-        parent_folder = ctx.web.get_folder_by_server_relative_path(full_path)
-        new_folder = parent_folder.folders.add(folder_name).execute_query()
-        
+        # Use Graph API to create folder
+        await asyncio.to_thread(
+            graph_client.create_folder,
+            folder_path,
+            folder_name
+        )
+
         return [TextContent(
             type="text",
-            text=f"✓ Successfully created folder '{folder_name}' in '{full_path}'"
+            text=f"✓ Successfully created folder '{folder_name}' in '{folder_path or 'root'}'"
         )]
-        
+
     except Exception as e:
         return [TextContent(type="text", text=f"Error creating folder: {str(e)}")]
 
 
 async def delete_folder(folder_path: str) -> list[TextContent]:
-    """Delete a folder"""
+    """Delete a folder using Microsoft Graph API"""
     try:
-        doc_lib = get_document_library_path()
-        full_path = f"{doc_lib}/{folder_path}"
-        
-        folder = ctx.web.get_folder_by_server_relative_path(full_path)
-        folder.delete_object().execute_query()
-        
+        # Use Graph API to delete folder
+        await asyncio.to_thread(graph_client.delete_folder, folder_path)
+
         return [TextContent(
             type="text",
             text=f"✓ Successfully deleted folder '{folder_path}'"
         )]
-        
+
     except Exception as e:
         return [TextContent(type="text", text=f"Error deleting folder: {str(e)}")]
 
 
 async def get_tree(folder_path: str = "", max_depth: int = 5, current_depth: int = 0) -> list[TextContent]:
-    """Get folder tree structure"""
+    """Get folder tree structure using Microsoft Graph API"""
     if current_depth >= max_depth:
         return [TextContent(type="text", text="Max depth reached")]
 
     try:
-        doc_lib = get_document_library_path()
-        full_path = f"{doc_lib}/{folder_path}" if folder_path else doc_lib
-
-        folder = ctx.web.get_folder_by_server_relative_path(full_path)
-        folders = folder.folders.get().execute_query()
+        # Use Graph API to list folders
+        folders = await asyncio.to_thread(graph_client.list_folders, folder_path)
 
         indent = "  " * current_depth
         tree_lines = [f"{indent}📁 {folder_path or 'Root'}"]
 
         for f in folders:
-            sub_path = f"{folder_path}/{f.name}" if folder_path else f.name
+            sub_path = f"{folder_path}/{f['name']}" if folder_path else f['name']
             sub_tree = await get_tree(sub_path, max_depth, current_depth + 1)
             tree_lines.append(sub_tree[0].text)
 
         return [TextContent(type="text", text="\n".join(tree_lines))]
 
-    except TypeError as e:
-        if "can't compare offset-naive and offset-aware datetimes" in str(e):
-            logger.error(
-                f"DateTime comparison error occurred despite patch. "
-                f"This may indicate a new code path in the library. Error: {e}"
-            )
-            return [TextContent(
-                type="text",
-                text=f"Encountered a datetime comparison issue. "
-                     f"A workaround patch is applied, but this specific code path may need attention.\n"
-                     f"Alternative: Use List_SharePoint_Folders for folder navigation."
-            )]
-        raise
     except Exception as e:
         return [TextContent(type="text", text=f"Error getting tree: {str(e)}")]
 

{mcp_sharepoint_us-2.0.11 → mcp_sharepoint_us-2.0.13}/src/mcp_sharepoint/auth.py

@@ -7,7 +7,6 @@ import logging
 import time
 import random
 from typing import Optional
-from urllib.parse import urlparse
 from datetime import datetime, timezone
 from office365.sharepoint.client_context import ClientContext
 from office365.runtime.auth.client_credential import ClientCredential
@@ -85,7 +84,17 @@ class SharePointAuthenticator:
         self.cert_path = cert_path
         self.cert_thumbprint = cert_thumbprint
         self.cloud = cloud.lower()
-        
+
+        # Initialize token cache
+        self._access_token = None
+        self._access_token_exp = 0
+
+        # Set Graph API scope based on cloud environment
+        if self.cloud in ("government", "us"):
+            self._scopes = ["https://graph.microsoft.us/.default"]
+        else:
+            self._scopes = ["https://graph.microsoft.com/.default"]
+
     def get_context_with_msal(self) -> ClientContext:
         """
         Get ClientContext using MSAL for modern Azure AD authentication.
@@ -123,19 +132,7 @@ class SharePointAuthenticator:
             self._msal_app = msal.ConfidentialClientApplication(**msal_params)
             self._authority_url = authority_url
 
-        # Small in-memory access-token cache (avoid repeated acquire calls)
-        # MSAL caches too, but keeping the raw token avoids extra work in Office365 callbacks.
-        if not hasattr(self, "_access_token"):
-            self._access_token = None
-            self._access_token_exp = 0
-
-        # Extract root SharePoint URL for scope
-        # For https://tenant.sharepoint.us/sites/SiteName -> https://tenant.sharepoint.us
-        parsed = urlparse(self.site_url)
-        sharepoint_root = f"{parsed.scheme}://{parsed.netloc}"
-        scopes = [f"{sharepoint_root}/.default"]
-
-        logger.info(f"Using SharePoint root scope: {sharepoint_root}/.default")
+        logger.info(f"Using Graph API scope: {self._scopes[0]}")
 
         def acquire_token():
             """
@@ -153,7 +150,7 @@ class SharePointAuthenticator:
             last_err = None
             for attempt in range(1, 6):  # 5 attempts
                 try:
-                    result = self._msal_app.acquire_token_for_client(scopes=scopes)
+                    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")
@@ -161,7 +158,7 @@ class SharePointAuthenticator:
                         raise ValueError(
                             f"Failed to acquire token: {error} - {error_desc}\n"
                             f"Authority: {self._authority_url}\n"
-                            f"Scopes: {scopes}"
+                            f"Scopes: {self._scopes}"
                         )
 
                     token = result["access_token"]
@@ -191,7 +188,83 @@ class SharePointAuthenticator:
         logger.info("Successfully authenticated using MSAL (Modern Azure AD)")
         return ctx
 
-    
+    def get_access_token(self) -> str:
+        """
+        Get access token directly for use with Microsoft Graph API.
+        Uses the same retry logic as get_context_with_msal() but returns just the token string.
+
+        Returns:
+            Access token as string
+
+        Raises:
+            RuntimeError: If token acquisition fails after retries
+        """
+        # Initialize MSAL app if not already done
+        if not hasattr(self, "_msal_app"):
+            if self.cloud in ("government", "us"):
+                authority_url = f"https://login.microsoftonline.us/{self.tenant_id}"
+                logger.info("Using Azure US Government Cloud endpoints")
+            else:
+                authority_url = f"https://login.microsoftonline.com/{self.tenant_id}"
+                logger.info("Using Azure Commercial Cloud endpoints")
+
+            self._token_cache = msal.SerializableTokenCache()
+
+            msal_params = {
+                "authority": authority_url,
+                "client_id": self.client_id,
+                "client_credential": self.client_secret,
+                "token_cache": self._token_cache,
+            }
+
+            if self.cloud in ("government", "us"):
+                msal_params["validate_authority"] = False
+                logger.info("Disabled authority validation for government cloud")
+
+            self._msal_app = msal.ConfidentialClientApplication(**msal_params)
+            self._authority_url = authority_url
+
+        now = int(time.time())
+        if self._access_token and now < (self._access_token_exp - 60):
+            return self._access_token
+
+        last_err = None
+        for attempt in range(1, 6):  # 5 attempts
+            try:
+                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")
+                    raise ValueError(
+                        f"Failed to acquire token: {error} - {error_desc}\n"
+                        f"Authority: {self._authority_url}\n"
+                        f"Scopes: {self._scopes}"
+                    )
+
+                token = result["access_token"]
+
+                # MSAL returns expires_in (seconds) for client credential tokens
+                expires_in = int(result.get("expires_in", 3600))
+                self._access_token = token
+                self._access_token_exp = int(time.time()) + expires_in
+
+                logger.info(f"Successfully acquired Graph API token")
+                return token
+
+            except Exception as e:
+                last_err = e
+                # Exponential backoff with jitter
+                sleep_s = min(8.0, (2 ** (attempt - 1)) * 0.5) + random.random() * 0.25
+                logger.warning(
+                    f"Token acquisition attempt {attempt}/5 failed: {e}. Retrying in {sleep_s:.2f}s"
+                )
+                time.sleep(sleep_s)
+
+        # If we get here, all retries failed
+        raise RuntimeError(f"Token acquisition failed after retries: {last_err}")
+
+
     def get_context_with_certificate(self) -> ClientContext:
         """
         Get ClientContext using certificate-based authentication.

mcp_sharepoint_us-2.0.13/src/mcp_sharepoint/graph_api.py

@@ -0,0 +1,328 @@
+"""
+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}'")

{mcp_sharepoint_us-2.0.11 → mcp_sharepoint_us-2.0.13}/src/mcp_sharepoint_us.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: mcp-sharepoint-us
-Version: 2.0.11
-Summary: SharePoint MCP Server with Modern Azure AD Authentication
+Version: 2.0.13
+Summary: SharePoint MCP Server with Microsoft Graph API
 License: MIT
 Project-URL: Homepage, https://github.com/mdev26/mcp-sharepoint-us
 Project-URL: Repository, https://github.com/mdev26/mcp-sharepoint-us
@@ -22,6 +22,7 @@ Requires-Dist: office365-rest-python-client>=2.5.0
 Requires-Dist: msal>=1.24.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: pydantic>=2.0.0
+Requires-Dist: requests>=2.31.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"

{mcp_sharepoint_us-2.0.11 → mcp_sharepoint_us-2.0.13}/src/mcp_sharepoint_us.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 src/mcp_sharepoint/__init__.py
 src/mcp_sharepoint/__main__.py
 src/mcp_sharepoint/auth.py
+src/mcp_sharepoint/graph_api.py
 src/mcp_sharepoint_us.egg-info/PKG-INFO
 src/mcp_sharepoint_us.egg-info/SOURCES.txt
 src/mcp_sharepoint_us.egg-info/dependency_links.txt

{mcp_sharepoint_us-2.0.11 → mcp_sharepoint_us-2.0.13}/src/mcp_sharepoint_us.egg-info/requires.txt

@@ -3,6 +3,7 @@ office365-rest-python-client>=2.5.0
 msal>=1.24.0
 python-dotenv>=1.0.0
 pydantic>=2.0.0
+requests>=2.31.0
 
 [dev]
 pytest>=7.0.0