google-workspace-mcp 1.0.2__py3-none-any.whl → 1.0.4__py3-none-any.whl

google_workspace_mcp/services/docs_service.py

@@ -4,6 +4,8 @@ Google Docs service implementation.
 
 import io
 import logging
+import urllib.parse
+import urllib.request
 from typing import Any
 
 from googleapiclient.discovery import build
@@ -42,7 +44,9 @@ class DocsService(BaseGoogleService):
             body = {"title": title}
             document = self.service.documents().create(body=body).execute()
             # The response includes documentId, title, and other fields.
-            logger.info(f"Successfully created document: {document.get('title')} (ID: {document.get('documentId')})")
+            logger.info(
+                f"Successfully created document: {document.get('title')} (ID: {document.get('documentId')})"
+            )
             return {
                 "document_id": document.get("documentId"),
                 "title": document.get("title"),
@@ -74,7 +78,11 @@ class DocsService(BaseGoogleService):
             logger.info(f"Fetching metadata for document ID: {document_id}")
             # The 'fields' parameter can be used to specify which fields to return.
             # e.g., "documentId,title,body,revisionId,suggestionsViewMode"
-            document = self.service.documents().get(documentId=document_id, fields="documentId,title").execute()
+            document = (
+                self.service.documents()
+                .get(documentId=document_id, fields="documentId,title")
+                .execute()
+            )
             logger.info(
                 f"Successfully fetched metadata for document: {document.get('title')} (ID: {document.get('documentId')})"
             )
@@ -84,10 +92,14 @@ class DocsService(BaseGoogleService):
                 "document_link": f"https://docs.google.com/document/d/{document.get('documentId')}/edit",
             }
         except HttpError as error:
-            logger.error(f"Error fetching document metadata for ID {document_id}: {error}")
+            logger.error(
+                f"Error fetching document metadata for ID {document_id}: {error}"
+            )
             return self.handle_api_error("get_document_metadata", error)
         except Exception as e:
-            logger.exception(f"Unexpected error fetching document metadata for ID {document_id}")
+            logger.exception(
+                f"Unexpected error fetching document metadata for ID {document_id}"
+            )
             return {
                 "error": True,
                 "error_type": "unexpected_service_error",
@@ -95,7 +107,9 @@ class DocsService(BaseGoogleService):
                 "operation": "get_document_metadata",
             }
 
-    def get_document_content_as_markdown(self, document_id: str) -> dict[str, Any] | None:
+    def get_document_content_as_markdown(
+        self, document_id: str
+    ) -> dict[str, Any] | None:
         """
         Retrieves the content of a Google Document as Markdown using Drive API export.
 
@@ -106,7 +120,9 @@ class DocsService(BaseGoogleService):
             A dictionary with 'document_id' and 'markdown_content', or an error dictionary.
         """
         try:
-            logger.info(f"Attempting to export document ID: {document_id} as Markdown via Drive API.")
+            logger.info(
+                f"Attempting to export document ID: {document_id} as Markdown via Drive API."
+            )
 
             # Obtain credentials
             credentials = gauth.get_credentials()
@@ -125,7 +141,9 @@ class DocsService(BaseGoogleService):
             # Attempt to export as 'text/markdown'
             # Not all environments or GDoc content might support 'text/markdown' perfectly.
             # 'text/plain' is a safer fallback.
-            request = drive_service_client.files().export_media(fileId=document_id, mimeType="text/markdown")
+            request = drive_service_client.files().export_media(
+                fileId=document_id, mimeType="text/markdown"
+            )
             fh = io.BytesIO()
             downloader = MediaIoBaseDownload(fh, request)
             done = False
@@ -136,10 +154,14 @@ class DocsService(BaseGoogleService):
             content_bytes = fh.getvalue()
 
             if content_bytes is None:
-                raise Exception("Failed to download exported content (bytes object is None).")
+                raise Exception(
+                    "Failed to download exported content (bytes object is None)."
+                )
 
             markdown_content = content_bytes.decode("utf-8")
-            logger.info(f"Successfully exported document ID: {document_id} to Markdown.")
+            logger.info(
+                f"Successfully exported document ID: {document_id} to Markdown."
+            )
             return {"document_id": document_id, "markdown_content": markdown_content}
 
         except HttpError as error:
@@ -148,9 +170,13 @@ class DocsService(BaseGoogleService):
                 f"HTTPError exporting document {document_id} as Markdown: {error}. Falling back to text/plain might be an option if this is a common issue for certain docs."
             )
             # For now, just return the error from the attempt.
-            return self.handle_api_error("get_document_content_as_markdown_drive_export", error)
+            return self.handle_api_error(
+                "get_document_content_as_markdown_drive_export", error
+            )
         except Exception as e:
-            logger.exception(f"Unexpected error exporting document {document_id} as Markdown: {e}")
+            logger.exception(
+                f"Unexpected error exporting document {document_id} as Markdown: {e}"
+            )
             return {
                 "error": True,
                 "error_type": "export_error",
@@ -158,7 +184,9 @@ class DocsService(BaseGoogleService):
                 "operation": "get_document_content_as_markdown",
             }
 
-    def append_text(self, document_id: str, text: str, ensure_newline: bool = True) -> dict[str, Any] | None:
+    def append_text(
+        self, document_id: str, text: str, ensure_newline: bool = True
+    ) -> dict[str, Any] | None:
         """
         Appends text to the end of a Google Document.
 
@@ -171,7 +199,9 @@ class DocsService(BaseGoogleService):
             A dictionary indicating success or an error dictionary.
         """
         try:
-            logger.info(f"Appending text to document ID: {document_id}. ensure_newline={ensure_newline}")
+            logger.info(
+                f"Appending text to document ID: {document_id}. ensure_newline={ensure_newline}"
+            )
 
             # To append at the end, we need to find the current end of the body segment.
             # Get document to find end index. Fields "body(content(endIndex))" might be enough.
@@ -180,7 +210,9 @@ class DocsService(BaseGoogleService):
             # If ensure_newline, and doc is not empty, prepend "\n" to text.
 
             document = (
-                self.service.documents().get(documentId=document_id, fields="body(content(endIndex,paragraph))").execute()
+                self.service.documents()
+                .get(documentId=document_id, fields="body(content(endIndex,paragraph))")
+                .execute()
             )
             end_index = (
                 document.get("body", {}).get("content", [])[-1].get("endIndex")
@@ -189,21 +221,26 @@ class DocsService(BaseGoogleService):
             )
 
             text_to_insert = text
-            if ensure_newline and end_index > 1:  # A new doc might have an end_index of 1 for the initial implicit paragraph
+            if (
+                ensure_newline and end_index > 1
+            ):  # A new doc might have an end_index of 1 for the initial implicit paragraph
                 text_to_insert = "\n" + text
 
             requests = [
                 {
                     "insertText": {
                         "location": {
-                            "index": end_index - 1  # Insert before the final newline of the document/body
+                            "index": end_index
+                            - 1  # Insert before the final newline of the document/body
                         },
                         "text": text_to_insert,
                     }
                 }
             ]
 
-            self.service.documents().batchUpdate(documentId=document_id, body={"requests": requests}).execute()
+            self.service.documents().batchUpdate(
+                documentId=document_id, body={"requests": requests}
+            ).execute()
             logger.info(f"Successfully appended text to document ID: {document_id}")
             return {
                 "document_id": document_id,
@@ -214,7 +251,9 @@ class DocsService(BaseGoogleService):
             logger.error(f"Error appending text to document {document_id}: {error}")
             return self.handle_api_error("append_text", error)
         except Exception as e:
-            logger.exception(f"Unexpected error appending text to document {document_id}")
+            logger.exception(
+                f"Unexpected error appending text to document {document_id}"
+            )
             return {
                 "error": True,
                 "error_type": "unexpected_service_error",
@@ -222,7 +261,9 @@ class DocsService(BaseGoogleService):
                 "operation": "append_text",
             }
 
-    def prepend_text(self, document_id: str, text: str, ensure_newline: bool = True) -> dict[str, Any] | None:
+    def prepend_text(
+        self, document_id: str, text: str, ensure_newline: bool = True
+    ) -> dict[str, Any] | None:
         """
         Prepends text to the beginning of a Google Document.
 
@@ -235,14 +276,20 @@ class DocsService(BaseGoogleService):
             A dictionary indicating success or an error dictionary.
         """
         try:
-            logger.info(f"Prepending text to document ID: {document_id}. ensure_newline={ensure_newline}")
+            logger.info(
+                f"Prepending text to document ID: {document_id}. ensure_newline={ensure_newline}"
+            )
 
             text_to_insert = text
             # To prepend, we generally insert at index 1 (after the initial Body segment start).
             # If ensure_newline is true, and the document isn't empty, add a newline *after* the prepended text.
             # This requires checking if the document has existing content.
             if ensure_newline:
-                document = self.service.documents().get(documentId=document_id, fields="body(content(endIndex))").execute()
+                document = (
+                    self.service.documents()
+                    .get(documentId=document_id, fields="body(content(endIndex))")
+                    .execute()
+                )
                 current_content_exists = bool(document.get("body", {}).get("content"))
                 if current_content_exists:
                     text_to_insert = text + "\n"
@@ -259,7 +306,9 @@ class DocsService(BaseGoogleService):
                 }
             ]
 
-            self.service.documents().batchUpdate(documentId=document_id, body={"requests": requests}).execute()
+            self.service.documents().batchUpdate(
+                documentId=document_id, body={"requests": requests}
+            ).execute()
             logger.info(f"Successfully prepended text to document ID: {document_id}")
             return {
                 "document_id": document_id,
@@ -270,7 +319,9 @@ class DocsService(BaseGoogleService):
             logger.error(f"Error prepending text to document {document_id}: {error}")
             return self.handle_api_error("prepend_text", error)
         except Exception as e:
-            logger.exception(f"Unexpected error prepending text to document {document_id}")
+            logger.exception(
+                f"Unexpected error prepending text to document {document_id}"
+            )
             return {
                 "error": True,
                 "error_type": "unexpected_service_error",
@@ -302,7 +353,9 @@ class DocsService(BaseGoogleService):
             A dictionary indicating success or an error dictionary.
         """
         try:
-            logger.info(f"Inserting text into document ID: {document_id} at index: {index}, segment: {segment_id}")
+            logger.info(
+                f"Inserting text into document ID: {document_id} at index: {index}, segment: {segment_id}"
+            )
 
             # Default to index 1 if not provided, which usually targets the start of the body content.
             # For an empty document, this effectively adds text.
@@ -321,7 +374,9 @@ class DocsService(BaseGoogleService):
 
             requests = [request]
 
-            self.service.documents().batchUpdate(documentId=document_id, body={"requests": requests}).execute()
+            self.service.documents().batchUpdate(
+                documentId=document_id, body={"requests": requests}
+            ).execute()
             logger.info(f"Successfully inserted text into document ID: {document_id}")
             return {
                 "document_id": document_id,
@@ -332,7 +387,9 @@ class DocsService(BaseGoogleService):
             logger.error(f"Error inserting text into document {document_id}: {error}")
             return self.handle_api_error("insert_text", error)
         except Exception as e:
-            logger.exception(f"Unexpected error inserting text into document {document_id}")
+            logger.exception(
+                f"Unexpected error inserting text into document {document_id}"
+            )
             return {
                 "error": True,
                 "error_type": "unexpected_service_error",
@@ -340,7 +397,9 @@ class DocsService(BaseGoogleService):
                 "operation": "insert_text",
             }
 
-    def batch_update(self, document_id: str, requests: list[dict]) -> dict[str, Any] | None:
+    def batch_update(
+        self, document_id: str, requests: list[dict]
+    ) -> dict[str, Any] | None:
         """
         Applies a list of update requests to the specified Google Document.
 
@@ -354,16 +413,24 @@ class DocsService(BaseGoogleService):
             or an error dictionary.
         """
         try:
-            logger.info(f"Executing batchUpdate for document ID: {document_id} with {len(requests)} requests.")
+            logger.info(
+                f"Executing batchUpdate for document ID: {document_id} with {len(requests)} requests."
+            )
             if not requests:
-                logger.warning(f"batchUpdate called with no requests for document ID: {document_id}")
+                logger.warning(
+                    f"batchUpdate called with no requests for document ID: {document_id}"
+                )
                 return {
                     "document_id": document_id,
                     "replies": [],
                     "message": "No requests provided.",
                 }
 
-            response = self.service.documents().batchUpdate(documentId=document_id, body={"requests": requests}).execute()
+            response = (
+                self.service.documents()
+                .batchUpdate(documentId=document_id, body={"requests": requests})
+                .execute()
+            )
             # The response object contains a list of 'replies', one for each request,
             # or it might be empty if all requests were successful without specific replies.
             # It also contains 'writeControl' and 'documentId'.
@@ -376,13 +443,197 @@ class DocsService(BaseGoogleService):
                 "write_control": response.get("writeControl"),
             }
         except HttpError as error:
-            logger.error(f"Error during batchUpdate for document {document_id}: {error}")
+            logger.error(
+                f"Error during batchUpdate for document {document_id}: {error}"
+            )
             return self.handle_api_error("batch_update", error)
         except Exception as e:
-            logger.exception(f"Unexpected error during batchUpdate for document {document_id}")
+            logger.exception(
+                f"Unexpected error during batchUpdate for document {document_id}"
+            )
             return {
                 "error": True,
                 "error_type": "unexpected_service_error",
                 "message": str(e),
                 "operation": "batch_update",
             }
+
+    def _validate_image_url(self, image_url: str) -> dict[str, Any] | None:
+        """
+        Validates an image URL for Google Docs API requirements.
+
+        Returns None if valid, or error dict if invalid.
+        """
+        if not image_url or not image_url.strip():
+            return {
+                "error": True,
+                "error_type": "validation_error",
+                "message": "Image URL cannot be empty",
+            }
+
+        # Check URL length (≤ 2kB)
+        if len(image_url) > 2048:
+            return {
+                "error": True,
+                "error_type": "validation_error",
+                "message": f"Image URL too long: {len(image_url)} chars (max: 2048)",
+            }
+
+        try:
+            # Make HEAD request to check accessibility and get metadata
+            req = urllib.request.Request(image_url, method="HEAD")
+            req.add_header("User-Agent", "Google-Workspace-MCP/1.0")
+
+            with urllib.request.urlopen(req, timeout=10) as response:
+                content_type = response.headers.get("Content-Type", "").lower()
+                content_length = response.headers.get("Content-Length")
+
+                # Check MIME type (PNG, JPEG, GIF only)
+                allowed_types = ["image/png", "image/jpeg", "image/jpg", "image/gif"]
+                if not any(
+                    allowed_type in content_type for allowed_type in allowed_types
+                ):
+                    return {
+                        "error": True,
+                        "error_type": "validation_error",
+                        "message": f"Unsupported image format: {content_type}. Must be PNG, JPEG, or GIF",
+                    }
+
+                # Check file size (< 50MB)
+                if content_length:
+                    size_mb = int(content_length) / (1024 * 1024)
+                    if size_mb >= 50:
+                        return {
+                            "error": True,
+                            "error_type": "validation_error",
+                            "message": f"Image too large: {size_mb:.1f}MB (max: 50MB)",
+                        }
+
+                return None  # Valid
+
+        except urllib.error.HTTPError as e:
+            return {
+                "error": True,
+                "error_type": "validation_error",
+                "message": f"Image URL not accessible: HTTP {e.code} {e.reason}",
+            }
+        except urllib.error.URLError as e:
+            return {
+                "error": True,
+                "error_type": "validation_error",
+                "message": f"Image URL not reachable: {e.reason}",
+            }
+        except Exception as e:
+            return {
+                "error": True,
+                "error_type": "validation_error",
+                "message": f"Failed to validate image URL: {str(e)}",
+            }
+
+    def insert_image(
+        self,
+        document_id: str,
+        image_url: str,
+        index: int,
+        width: float | None = None,
+        height: float | None = None,
+    ) -> dict[str, Any] | None:
+        """
+        Inserts an image into a Google Document from a URL at a specific index.
+
+        Args:
+            document_id: The ID of the Google Document.
+            image_url: The publicly accessible URL of the image to insert.
+            index: The 1-based index in the document where the image will be inserted.
+            width: Optional width of the image in points (PT).
+            height: Optional height of the image in points (PT).
+
+        Returns:
+            A dictionary containing the inserted image ID and success status, or an error dictionary.
+        """
+        try:
+            logger.info(f"Inserting image into document {document_id} at index {index}")
+
+            # Validate inputs
+            if not document_id or not document_id.strip():
+                raise ValueError("Document ID cannot be empty")
+
+            if not isinstance(index, int) or index < 1:
+                raise ValueError("Index must be a positive integer (1-based)")
+
+            # Validate image URL
+            validation_error = self._validate_image_url(image_url)
+            if validation_error:
+                return validation_error
+
+            # Build the insert image request
+            insert_request = {
+                "insertInlineImage": {
+                    "location": {
+                        "index": index - 1  # Convert to 0-based index for API
+                    },
+                    "uri": image_url,
+                }
+            }
+
+            # Add optional dimensions
+            if width is not None or height is not None:
+                insert_request["insertInlineImage"]["objectSize"] = {}
+                if width is not None:
+                    insert_request["insertInlineImage"]["objectSize"]["width"] = {
+                        "magnitude": width,
+                        "unit": "PT",
+                    }
+                if height is not None:
+                    insert_request["insertInlineImage"]["objectSize"]["height"] = {
+                        "magnitude": height,
+                        "unit": "PT",
+                    }
+
+            # Execute the batch update
+            result = (
+                self.service.documents()
+                .batchUpdate(
+                    documentId=document_id, body={"requests": [insert_request]}
+                )
+                .execute()
+            )
+
+            # Extract the inserted image ID from the reply
+            inserted_image_id = None
+            if result.get("replies") and len(result["replies"]) > 0:
+                reply = result["replies"][0]
+                if "insertInlineImage" in reply:
+                    inserted_image_id = reply["insertInlineImage"].get("objectId")
+
+            logger.info(
+                f"Successfully inserted image {inserted_image_id} into document {document_id}"
+            )
+
+            return {
+                "document_id": document_id,
+                "inserted_image_id": inserted_image_id,
+                "success": True,
+            }
+
+        except ValueError as e:
+            logger.error(f"Validation error inserting image: {e}")
+            return {
+                "error": True,
+                "error_type": "validation_error",
+                "message": str(e),
+                "operation": "insert_image",
+            }
+        except HttpError as error:
+            logger.error(f"Google Docs API error inserting image: {error}")
+            return self.handle_api_error("insert_image", error)
+        except Exception as e:
+            logger.exception(
+                f"Unexpected error inserting image into document {document_id}"
+            )
+            return {
+                "error": True,
+                "error_type": "unexpected_service_error",
+                "message": str(e),
+                "operation": "insert_image",
+            }

google_workspace_mcp/services/drive.py

@@ -4,14 +4,14 @@ Provides comprehensive file management capabilities through Google Drive API.
 """
 
 import base64
+import binascii
 import io
 import logging
 import mimetypes
-import os
 from typing import Any
 
 from googleapiclient.errors import HttpError
-from googleapiclient.http import MediaFileUpload, MediaIoBaseDownload
+from googleapiclient.http import MediaIoBaseDownload, MediaIoBaseUpload
 
 from google_workspace_mcp.services.base import BaseGoogleService
 
@@ -27,7 +27,9 @@ class DriveService(BaseGoogleService):
         """Initialize the Drive service."""
         super().__init__("drive", "v3")
 
-    def search_files(self, query: str, page_size: int = 10, shared_drive_id: str | None = None) -> list[dict[str, Any]]:
+    def search_files(
+        self, query: str, page_size: int = 10, shared_drive_id: str | None = None
+    ) -> list[dict[str, Any]]:
         """
         Search for files in Google Drive.
 
@@ -40,17 +42,16 @@ class DriveService(BaseGoogleService):
             List of file metadata dictionaries (id, name, mimeType, etc.) or an error dictionary
         """
         try:
-            logger.info(f"Searching files with query: '{query}', page_size: {page_size}, shared_drive_id: {shared_drive_id}")
+            logger.info(
+                f"Searching files with query: '{query}', page_size: {page_size}, shared_drive_id: {shared_drive_id}"
+            )
 
             # Validate and constrain page_size
             page_size = max(1, min(page_size, 1000))
 
-            # Format query with proper escaping
-            formatted_query = query.replace("'", "\\'")
-
             # Build list parameters with shared drive support
             list_params = {
-                "q": formatted_query,
+                "q": query,  # Use the query directly without modification
                 "pageSize": page_size,
                 "fields": "files(id, name, mimeType, modifiedTime, size, webViewLink, iconLink)",
                 "supportsAllDrives": True,
@@ -59,9 +60,13 @@ class DriveService(BaseGoogleService):
 
             if shared_drive_id:
                 list_params["driveId"] = shared_drive_id
-                list_params["corpora"] = "drive"  # Search within the specified shared drive
+                list_params["corpora"] = (
+                    "drive"  # Search within the specified shared drive
+                )
             else:
-                list_params["corpora"] = "user"  # Default to user's files if no specific shared drive ID
+                list_params["corpora"] = (
+                    "user"  # Default to user's files if no specific shared drive ID
+                )
 
             results = self.service.files().list(**list_params).execute()
             files = results.get("files", [])
@@ -84,12 +89,18 @@ class DriveService(BaseGoogleService):
         """
         try:
             # Get file metadata
-            file_metadata = self.service.files().get(fileId=file_id, fields="mimeType, name").execute()
+            file_metadata = (
+                self.service.files()
+                .get(fileId=file_id, fields="mimeType, name")
+                .execute()
+            )
 
             original_mime_type = file_metadata.get("mimeType")
             file_name = file_metadata.get("name", "Unknown")
 
-            logger.info(f"Reading file '{file_name}' ({file_id}) with mimeType: {original_mime_type}")
+            logger.info(
+                f"Reading file '{file_name}' ({file_id}) with mimeType: {original_mime_type}"
+            )
 
             # Handle Google Workspace files by exporting
             if original_mime_type.startswith("application/vnd.google-apps."):
@@ -129,7 +140,9 @@ class DriveService(BaseGoogleService):
                 .execute()
             )
 
-            logger.info(f"Successfully retrieved metadata for file: {file_metadata.get('name', 'Unknown')}")
+            logger.info(
+                f"Successfully retrieved metadata for file: {file_metadata.get('name', 'Unknown')}"
+            )
             return file_metadata
 
         except Exception as e:
@@ -185,13 +198,17 @@ class DriveService(BaseGoogleService):
 
             created_folder = self.service.files().create(**create_params).execute()
 
-            logger.info(f"Successfully created folder '{folder_name}' with ID: {created_folder.get('id')}")
+            logger.info(
+                f"Successfully created folder '{folder_name}' with ID: {created_folder.get('id')}"
+            )
             return created_folder
 
         except Exception as e:
             return self.handle_api_error("create_folder", e)
 
-    def _export_google_file(self, file_id: str, file_name: str, mime_type: str) -> dict[str, Any]:
+    def _export_google_file(
+        self, file_id: str, file_name: str, mime_type: str
+    ) -> dict[str, Any]:
         """Export a Google Workspace file in an appropriate format."""
         # Determine export format
         export_mime_type = None
@@ -216,7 +233,9 @@ class DriveService(BaseGoogleService):
 
         # Export the file
         try:
-            request = self.service.files().export_media(fileId=file_id, mimeType=export_mime_type, supportsAllDrives=True)
+            request = self.service.files().export_media(
+                fileId=file_id, mimeType=export_mime_type
+            )
 
             content_bytes = self._download_content(request)
             if isinstance(content_bytes, dict) and content_bytes.get("error"):
@@ -248,7 +267,9 @@ class DriveService(BaseGoogleService):
         except Exception as e:
             return self.handle_api_error("_export_google_file", e)
 
-    def _download_regular_file(self, file_id: str, file_name: str, mime_type: str) -> dict[str, Any]:
+    def _download_regular_file(
+        self, file_id: str, file_name: str, mime_type: str
+    ) -> dict[str, Any]:
         """Download a regular (non-Google Workspace) file."""
         request = self.service.files().get_media(fileId=file_id, supportsAllDrives=True)
 
@@ -262,7 +283,9 @@ class DriveService(BaseGoogleService):
                 content = content_bytes.decode("utf-8")
                 return {"mimeType": mime_type, "content": content, "encoding": "utf-8"}
             except UnicodeDecodeError:
-                logger.warning(f"UTF-8 decoding failed for file {file_id} ('{file_name}', {mime_type}). Using base64.")
+                logger.warning(
+                    f"UTF-8 decoding failed for file {file_id} ('{file_name}', {mime_type}). Using base64."
+                )
                 content = base64.b64encode(content_bytes).decode("utf-8")
                 return {
                     "mimeType": mime_type,
@@ -289,61 +312,60 @@ class DriveService(BaseGoogleService):
         except Exception as e:
             return self.handle_api_error("download_content", e)
 
-    def upload_file(
+    def upload_file_content(
         self,
-        file_path: str,
+        filename: str,
+        content_base64: str,
         parent_folder_id: str | None = None,
         shared_drive_id: str | None = None,
     ) -> dict[str, Any]:
         """
-        Upload a file to Google Drive.
+        Upload a file to Google Drive using its content.
 
         Args:
-            file_path: Path to the local file to upload
-            parent_folder_id: Optional parent folder ID to upload the file to
-            shared_drive_id: Optional shared drive ID to upload the file to a shared drive
+            filename: The name for the file in Google Drive.
+            content_base64: Base64 encoded content of the file.
+            parent_folder_id: Optional parent folder ID.
+            shared_drive_id: Optional shared drive ID.
 
         Returns:
-            Dict containing file metadata on success, or error information on failure
+            Dict containing file metadata on success, or error information on failure.
         """
         try:
-            # Check if file exists locally
-            if not os.path.exists(file_path):
-                logger.error(f"Local file not found for upload: {file_path}")
+            logger.info(f"Uploading file '{filename}' from content.")
+
+            # Decode the base64 content
+            try:
+                content_bytes = base64.b64decode(content_base64, validate=True)
+            except (ValueError, TypeError, binascii.Error) as e:
+                logger.error(f"Invalid base64 content for file '{filename}': {e}")
                 return {
                     "error": True,
-                    "error_type": "local_file_error",
-                    "message": f"Local file not found: {file_path}",
-                    "operation": "upload_file",
+                    "error_type": "invalid_content",
+                    "message": "Invalid base64 encoded content provided.",
+                    "operation": "upload_file_content",
                 }
 
-            file_name = os.path.basename(file_path)
-            logger.info(f"Uploading file '{file_name}' from path: {file_path}")
-
-            # Get file MIME type
-            mime_type, _ = mimetypes.guess_type(file_path)
+            # Get file MIME type from filename
+            mime_type, _ = mimetypes.guess_type(filename)
             if mime_type is None:
                 mime_type = "application/octet-stream"
 
-            file_metadata = {"name": file_name}
-
-            # Set parent folder if specified
+            file_metadata = {"name": filename}
             if parent_folder_id:
                 file_metadata["parents"] = [parent_folder_id]
             elif shared_drive_id:
-                # If shared drive is specified but no parent, set shared drive as parent
                 file_metadata["parents"] = [shared_drive_id]
 
-            media = MediaFileUpload(file_path, mimetype=mime_type)
+            # Use MediaIoBaseUpload for in-memory content
+            media = MediaIoBaseUpload(io.BytesIO(content_bytes), mimetype=mime_type)
 
-            # Prepare create parameters
             create_params = {
                 "body": file_metadata,
                 "media_body": media,
                 "fields": "id,name,mimeType,modifiedTime,size,webViewLink",
                 "supportsAllDrives": True,
             }
-
             if shared_drive_id:
                 create_params["driveId"] = shared_drive_id
 
@@ -353,14 +375,14 @@ class DriveService(BaseGoogleService):
             return file
 
         except HttpError as e:
-            return self.handle_api_error("upload_file", e)
+            return self.handle_api_error("upload_file_content", e)
         except Exception as e:
-            logger.error(f"Non-API error in upload_file: {str(e)}")
+            logger.error(f"Non-API error in upload_file_content: {str(e)}")
             return {
                 "error": True,
                 "error_type": "local_error",
-                "message": f"Error uploading file: {str(e)}",
-                "operation": "upload_file",
+                "message": f"Error uploading file from content: {str(e)}",
+                "operation": "upload_file_content",
             }
 
     def delete_file(self, file_id: str) -> dict[str, Any]:
@@ -400,7 +422,11 @@ class DriveService(BaseGoogleService):
             # API allows pageSize up to 100 for drives.list
             actual_page_size = min(max(1, page_size), 100)
 
-            results = self.service.drives().list(pageSize=actual_page_size, fields="drives(id, name, kind)").execute()
+            results = (
+                self.service.drives()
+                .list(pageSize=actual_page_size, fields="drives(id, name, kind)")
+                .execute()
+            )
             drives = results.get("drives", [])
 
             # Filter for kind='drive#drive' just to be sure, though API should only return these

google_workspace_mcp/tools/docs_tools.py

@@ -37,7 +37,9 @@ async def docs_create_document(title: str) -> dict[str, Any]:
         raise ValueError(result.get("message", "Error creating document"))
 
     if not result or not result.get("document_id"):
-        raise ValueError(f"Failed to create document '{title}' or did not receive a document ID.")
+        raise ValueError(
+            f"Failed to create document '{title}' or did not receive a document ID."
+        )
 
     return result
 
@@ -57,7 +59,9 @@ async def docs_get_document_metadata(document_id: str) -> dict[str, Any]:
         A dictionary containing the document's 'document_id', 'title', and 'document_link',
         or an error message.
     """
-    logger.info(f"Executing docs_get_document_metadata tool for document_id: '{document_id}'")
+    logger.info(
+        f"Executing docs_get_document_metadata tool for document_id: '{document_id}'"
+    )
     if not document_id or not document_id.strip():
         raise ValueError("Document ID cannot be empty.")
 
@@ -88,7 +92,9 @@ async def docs_get_content_as_markdown(document_id: str) -> dict[str, Any]:
         A dictionary containing the 'document_id' and 'markdown_content',
         or an error message.
     """
-    logger.info(f"Executing docs_get_content_as_markdown tool for document_id: '{document_id}'")
+    logger.info(
+        f"Executing docs_get_content_as_markdown tool for document_id: '{document_id}'"
+    )
     if not document_id or not document_id.strip():
         raise ValueError("Document ID cannot be empty.")
 
@@ -96,10 +102,14 @@ async def docs_get_content_as_markdown(document_id: str) -> dict[str, Any]:
     result = docs_service.get_document_content_as_markdown(document_id=document_id)
 
     if isinstance(result, dict) and result.get("error"):
-        raise ValueError(result.get("message", "Error retrieving document content as Markdown"))
+        raise ValueError(
+            result.get("message", "Error retrieving document content as Markdown")
+        )
 
     if not result or "markdown_content" not in result:
-        raise ValueError(f"Failed to retrieve Markdown content for document '{document_id}'.")
+        raise ValueError(
+            f"Failed to retrieve Markdown content for document '{document_id}'."
+        )
 
     return result
 
@@ -108,7 +118,9 @@ async def docs_get_content_as_markdown(document_id: str) -> dict[str, Any]:
     name="docs_append_text",
     description="Appends text to the end of a specified Google Document.",
 )
-async def docs_append_text(document_id: str, text: str, ensure_newline: bool = True) -> dict[str, Any]:
+async def docs_append_text(
+    document_id: str, text: str, ensure_newline: bool = True
+) -> dict[str, Any]:
     """
     Appends the given text to the end of the specified Google Document.
 
@@ -127,7 +139,9 @@ async def docs_append_text(document_id: str, text: str, ensure_newline: bool = T
     # Text can be empty, that's fine.
 
     docs_service = DocsService()
-    result = docs_service.append_text(document_id=document_id, text=text, ensure_newline=ensure_newline)
+    result = docs_service.append_text(
+        document_id=document_id, text=text, ensure_newline=ensure_newline
+    )
 
     if isinstance(result, dict) and result.get("error"):
         raise ValueError(result.get("message", "Error appending text to document"))
@@ -142,7 +156,9 @@ async def docs_append_text(document_id: str, text: str, ensure_newline: bool = T
     name="docs_prepend_text",
     description="Prepends text to the beginning of a specified Google Document.",
 )
-async def docs_prepend_text(document_id: str, text: str, ensure_newline: bool = True) -> dict[str, Any]:
+async def docs_prepend_text(
+    document_id: str, text: str, ensure_newline: bool = True
+) -> dict[str, Any]:
     """
     Prepends the given text to the beginning of the specified Google Document.
 
@@ -161,7 +177,9 @@ async def docs_prepend_text(document_id: str, text: str, ensure_newline: bool =
     # Text can be empty, that's fine.
 
     docs_service = DocsService()
-    result = docs_service.prepend_text(document_id=document_id, text=text, ensure_newline=ensure_newline)
+    result = docs_service.prepend_text(
+        document_id=document_id, text=text, ensure_newline=ensure_newline
+    )
 
     if isinstance(result, dict) and result.get("error"):
         raise ValueError(result.get("message", "Error prepending text to document"))
@@ -195,13 +213,17 @@ async def docs_insert_text(
     Returns:
         A dictionary indicating success or an error message.
     """
-    logger.info(f"Executing docs_insert_text tool for document_id: '{document_id}' at index: {index}")
+    logger.info(
+        f"Executing docs_insert_text tool for document_id: '{document_id}' at index: {index}"
+    )
     if not document_id or not document_id.strip():
         raise ValueError("Document ID cannot be empty.")
     # Text can be empty, that's a valid insertion (though perhaps not useful).
 
     docs_service = DocsService()
-    result = docs_service.insert_text(document_id=document_id, text=text, index=index, segment_id=segment_id)
+    result = docs_service.insert_text(
+        document_id=document_id, text=text, index=index, segment_id=segment_id
+    )
 
     if isinstance(result, dict) and result.get("error"):
         raise ValueError(result.get("message", "Error inserting text into document"))
@@ -231,7 +253,9 @@ async def docs_batch_update(document_id: str, requests: list[dict]) -> dict[str,
         A dictionary containing the API response from the batchUpdate call (includes replies for each request),
         or an error message.
     """
-    logger.info(f"Executing docs_batch_update tool for document_id: '{document_id}' with {len(requests)} requests.")
+    logger.info(
+        f"Executing docs_batch_update tool for document_id: '{document_id}' with {len(requests)} requests."
+    )
     if not document_id or not document_id.strip():
         raise ValueError("Document ID cannot be empty.")
     if not isinstance(requests, list):
@@ -243,9 +267,72 @@ async def docs_batch_update(document_id: str, requests: list[dict]) -> dict[str,
     result = docs_service.batch_update(document_id=document_id, requests=requests)
 
     if isinstance(result, dict) and result.get("error"):
-        raise ValueError(result.get("message", "Error executing batch update on document"))
+        raise ValueError(
+            result.get("message", "Error executing batch update on document")
+        )
 
     if not result:  # Should be caught by error dict check
         raise ValueError(f"Failed to execute batch update on document '{document_id}'.")
 
     return result  # Return the full response which includes documentId and replies
+
+
+@mcp.tool(
+    name="docs_insert_image",
+    description="Inserts an image into a Google Document from a URL at a specific index. The image URL must be publicly accessible and in PNG, JPEG, or GIF format.",
+)
+async def docs_insert_image(
+    document_id: str,
+    image_url: str,
+    index: int,
+    width: float | None = None,
+    height: float | None = None,
+) -> dict[str, Any]:
+    """
+    Inserts an image into a Google Document from a URL at a specific index.
+
+    Args:
+        document_id: The ID of the Google Document.
+        image_url: The publicly accessible URL of the image to insert.
+        index: The 1-based index in the document where the image will be inserted.
+        width: Optional width of the image in points (PT).
+        height: Optional height of the image in points (PT).
+
+    Returns:
+        A dictionary containing the inserted image ID and success status, or an error message.
+    """
+    logger.info(
+        f"Executing docs_insert_image tool for document_id: '{document_id}' at index: {index}"
+    )
+
+    if not document_id or not document_id.strip():
+        raise ValueError("Document ID cannot be empty.")
+
+    if not image_url or not image_url.strip():
+        raise ValueError("Image URL cannot be empty.")
+
+    if not isinstance(index, int) or index < 1:
+        raise ValueError("Index must be a positive integer (1-based).")
+
+    if width is not None and (not isinstance(width, int | float) or width <= 0):
+        raise ValueError("Width must be a positive number.")
+
+    if height is not None and (not isinstance(height, int | float) or height <= 0):
+        raise ValueError("Height must be a positive number.")
+
+    docs_service = DocsService()
+    result = docs_service.insert_image(
+        document_id=document_id,
+        image_url=image_url,
+        index=index,
+        width=width,
+        height=height,
+    )
+
+    if isinstance(result, dict) and result.get("error"):
+        raise ValueError(result.get("message", "Error inserting image into document"))
+
+    if not result or not result.get("success"):
+        raise ValueError(f"Failed to insert image into document '{document_id}'.")
+
+    return result

google_workspace_mcp/tools/drive.py

@@ -42,7 +42,9 @@ async def drive_search_files(
         raise ValueError("Query cannot be empty")
 
     drive_service = DriveService()
-    files = drive_service.search_files(query=query, page_size=page_size, shared_drive_id=shared_drive_id)
+    files = drive_service.search_files(
+        query=query, page_size=page_size, shared_drive_id=shared_drive_id
+    )
 
     if isinstance(files, dict) and files.get("error"):
         raise ValueError(f"Search failed: {files.get('message', 'Unknown error')}")
@@ -82,18 +84,20 @@ async def drive_read_file_content(file_id: str) -> dict[str, Any]:
 
 @mcp.tool(
     name="drive_upload_file",
-    description="Upload a local file to Google Drive. Requires a local file path.",
+    description="Uploads a file to Google Drive by providing its content directly.",
 )
 async def drive_upload_file(
-    file_path: str,
+    filename: str,
+    content_base64: str,
     parent_folder_id: str | None = None,
     shared_drive_id: str | None = None,
 ) -> dict[str, Any]:
     """
-    Upload a local file to Google Drive.
+    Uploads a file to Google Drive using its base64 encoded content.
 
     Args:
-        file_path: Path to the local file to upload.
+        filename: The desired name for the file in Google Drive (e.g., "report.pdf").
+        content_base64: The content of the file, encoded in base64.
         parent_folder_id: Optional parent folder ID to upload the file to.
         shared_drive_id: Optional shared drive ID to upload the file to a shared drive.
 
@@ -101,14 +105,17 @@ async def drive_upload_file(
         A dictionary containing the uploaded file metadata or an error.
     """
     logger.info(
-        f"Executing drive_upload_file with path: '{file_path}', parent_folder_id: {parent_folder_id}, shared_drive_id: {shared_drive_id}"
+        f"Executing drive_upload_file with filename: '{filename}', parent_folder_id: {parent_folder_id}, shared_drive_id: {shared_drive_id}"
     )
-    if not file_path or not file_path.strip():
-        raise ValueError("File path cannot be empty")
+    if not filename or not filename.strip():
+        raise ValueError("Filename cannot be empty")
+    if not content_base64 or not content_base64.strip():
+        raise ValueError("File content (content_base64) cannot be empty")
 
     drive_service = DriveService()
-    result = drive_service.upload_file(
-        file_path=file_path,
+    result = drive_service.upload_file_content(
+        filename=filename,
+        content_base64=content_base64,
         parent_folder_id=parent_folder_id,
         shared_drive_id=shared_drive_id,
     )
@@ -154,7 +161,9 @@ async def drive_create_folder(
     )
 
     if isinstance(result, dict) and result.get("error"):
-        raise ValueError(f"Folder creation failed: {result.get('message', 'Unknown error')}")
+        raise ValueError(
+            f"Folder creation failed: {result.get('message', 'Unknown error')}"
+        )
 
     return result
 

{google_workspace_mcp-1.0.2.dist-info → google_workspace_mcp-1.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-workspace-mcp
-Version: 1.0.2
+Version: 1.0.4
 Summary: MCP server for Google Workspace integration
 Author-email: Arclio Team <info@arclio.com>
 License: MIT
@@ -11,7 +11,7 @@ Requires-Dist: google-auth-httplib2>=0.1.0
 Requires-Dist: google-auth-oauthlib>=1.0.0
 Requires-Dist: google-auth>=2.22.0
 Requires-Dist: markdown>=3.5.0
-Requires-Dist: markdowndeck>=0.1.1
+Requires-Dist: markdowndeck>=0.1.3
 Requires-Dist: mcp>=1.7.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: pytz>=2023.3

{google_workspace_mcp-1.0.2.dist-info → google_workspace_mcp-1.0.4.dist-info}/RECORD

@@ -18,21 +18,21 @@ google_workspace_mcp/resources/slides.py,sha256=m2KVCYUOJ9uKMVWXXw9lXNem3OFT438X
 google_workspace_mcp/services/__init__.py,sha256=crw4YinYFi7QDfJZUCcUqPliRtlViSE7QSqAX8j33eE,473
 google_workspace_mcp/services/base.py,sha256=uLtFB158kaY_n3JWKgW2kxQ2tx9SP9zxX-PWuPxydFI,2378
 google_workspace_mcp/services/calendar.py,sha256=_FvgDKfMvFWIamDHOimY3cVK2zPk0o7iUbbKeJehaHY,8370
-google_workspace_mcp/services/docs_service.py,sha256=KRNn4iAjeQJjC3loR3zCQQ-RV7S6-qaWwaT_SvT4onk,17297
-google_workspace_mcp/services/drive.py,sha256=iE5IyzA52Wm21ItIlhBnPPsiSkarZbnNc4mcBOmMdU8,16361
+google_workspace_mcp/services/docs_service.py,sha256=e67bvDb0lAmDbSXYRxPAIH93rXPbHS0Fq07c-eBcy08,25286
+google_workspace_mcp/services/drive.py,sha256=9ReL9XkRLpK7ZS1KngHVv2ZGykeOo4N5ncp-gSYcAEA,16804
 google_workspace_mcp/services/gmail.py,sha256=M6trjL9uFOe5WnBORyic4Y7lU4Z0X9VnEq-yU7RY-No,24846
 google_workspace_mcp/services/sheets_service.py,sha256=67glYCTuQynka_vAXxCsM2U5SMuRNXXpTff2G-X-fT0,18068
 google_workspace_mcp/services/slides.py,sha256=qfXh6GBr2JkCGPgVmwvV4NapLlzF7A1_WlYQR8EXMEE,37310
 google_workspace_mcp/tools/__init__.py,sha256=vwa7hV8HwrLqs3Sf7RTrt1MlVZ-KjptXuFDSJt5tWzA,107
 google_workspace_mcp/tools/calendar.py,sha256=KX42ZHNMcO69GuU-Re-37HY1Kk0jGM0dwUSrkexi_So,7890
-google_workspace_mcp/tools/docs_tools.py,sha256=BbfLJKAZnKlfHLluM3iZE9oxMELX066xR7qzHkN4PbM,10313
-google_workspace_mcp/tools/drive.py,sha256=Goj5v9RpQAq5yuSeX_uAkCYAy_7wnaQLo5wDqBlSTLg,6766
+google_workspace_mcp/tools/docs_tools.py,sha256=L4zgjBAZxGYEnvNzUj_-leNXc1tIghzmDBinng2uMjI,12677
+google_workspace_mcp/tools/drive.py,sha256=HUL_ozcTvWOIXKM0eQpLLYY6Yu_V2aFyhPVWW8GTpyw,7132
 google_workspace_mcp/tools/gmail.py,sha256=nkbN6IC8yhSxrNwxUVRh9qAakomKJjGP4-MEKJoTnpA,11269
 google_workspace_mcp/tools/sheets_tools.py,sha256=1lC_6oeXCZQDFI4f_hHrOZOnu-t6iVeQ2ErYwhS172Q,11760
 google_workspace_mcp/tools/slides.py,sha256=GTtkIaQf6GMtzaxu8wlAemWcY5n5Y6RMEwWILPoiMFo,15382
 google_workspace_mcp/utils/__init__.py,sha256=jKEfO2DhR_lwsRSoUgceixDwzkGVlp_vmbrz_6AHOk0,50
 google_workspace_mcp/utils/markdown_slides.py,sha256=G7EbK3DDki90hNilGzbczs2e345v-HjYB5GWhFbEtw4,21015
-google_workspace_mcp-1.0.2.dist-info/METADATA,sha256=LErDxvUnRAF41NWSoNB40MLuId9zBC4g5PQet3WfSCU,25104
-google_workspace_mcp-1.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-google_workspace_mcp-1.0.2.dist-info/entry_points.txt,sha256=t9eBYTnGzEBpiiRx_SCTqforubwM6Ebf5mszIj-MjeA,79
-google_workspace_mcp-1.0.2.dist-info/RECORD,,
+google_workspace_mcp-1.0.4.dist-info/METADATA,sha256=wvx5j35AYP6PIi55dZYiokXZCU-t-xWjmK5XQjOVaD0,25104
+google_workspace_mcp-1.0.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+google_workspace_mcp-1.0.4.dist-info/entry_points.txt,sha256=t9eBYTnGzEBpiiRx_SCTqforubwM6Ebf5mszIj-MjeA,79
+google_workspace_mcp-1.0.4.dist-info/RECORD,,