workspace-mcp 0.2.0__py3-none-any.whl

gchat/chat_tools.py

@@ -0,0 +1,254 @@
+"""
+Google Chat MCP Tools
+
+This module provides MCP tools for interacting with Google Chat API.
+"""
+import logging
+import asyncio
+from typing import Optional
+
+from mcp import types
+from googleapiclient.errors import HttpError
+
+# Auth & server utilities
+from auth.service_decorator import require_google_service
+from core.server import server
+
+logger = logging.getLogger(__name__)
+
+@server.tool()
+@require_google_service("chat", "chat_read")
+async def list_spaces(
+    service,
+    user_google_email: str,
+    page_size: int = 100,
+    space_type: str = "all"  # "all", "room", "dm"
+) -> str:
+    """
+    Lists Google Chat spaces (rooms and direct messages) accessible to the user.
+
+    Returns:
+        str: A formatted list of Google Chat spaces accessible to the user.
+    """
+    logger.info(f"[list_spaces] Email={user_google_email}, Type={space_type}")
+
+    try:
+        # Build filter based on space_type
+        filter_param = None
+        if space_type == "room":
+            filter_param = "spaceType = SPACE"
+        elif space_type == "dm":
+            filter_param = "spaceType = DIRECT_MESSAGE"
+
+        request_params = {"pageSize": page_size}
+        if filter_param:
+            request_params["filter"] = filter_param
+
+        response = await asyncio.to_thread(
+            service.spaces().list(**request_params).execute
+        )
+
+        spaces = response.get('spaces', [])
+        if not spaces:
+            return f"No Chat spaces found for type '{space_type}'."
+
+        output = [f"Found {len(spaces)} Chat spaces (type: {space_type}):"]
+        for space in spaces:
+            space_name = space.get('displayName', 'Unnamed Space')
+            space_id = space.get('name', '')
+            space_type_actual = space.get('spaceType', 'UNKNOWN')
+            output.append(f"- {space_name} (ID: {space_id}, Type: {space_type_actual})")
+
+        return "\n".join(output)
+
+    except HttpError as e:
+        logger.error(f"API error in list_spaces: {e}", exc_info=True)
+        raise Exception(f"API error: {e}")
+    except Exception as e:
+        logger.exception(f"Unexpected error in list_spaces: {e}")
+        raise Exception(f"Unexpected error: {e}")
+
+@server.tool()
+@require_google_service("chat", "chat_read")
+async def get_messages(
+    service,
+    user_google_email: str,
+    space_id: str,
+    page_size: int = 50,
+    order_by: str = "createTime desc"
+) -> str:
+    """
+    Retrieves messages from a Google Chat space.
+
+    Returns:
+        str: Formatted messages from the specified space.
+    """
+    logger.info(f"[get_messages] Space ID: '{space_id}' for user '{user_google_email}'")
+
+    try:
+        # Get space info first
+        space_info = await asyncio.to_thread(
+            service.spaces().get(name=space_id).execute
+        )
+        space_name = space_info.get('displayName', 'Unknown Space')
+
+        # Get messages
+        response = await asyncio.to_thread(
+            service.spaces().messages().list(
+                parent=space_id,
+                pageSize=page_size,
+                orderBy=order_by
+            ).execute
+        )
+
+        messages = response.get('messages', [])
+        if not messages:
+            return f"No messages found in space '{space_name}' (ID: {space_id})."
+
+        output = [f"Messages from '{space_name}' (ID: {space_id}):\n"]
+        for msg in messages:
+            sender = msg.get('sender', {}).get('displayName', 'Unknown Sender')
+            create_time = msg.get('createTime', 'Unknown Time')
+            text_content = msg.get('text', 'No text content')
+            msg_name = msg.get('name', '')
+
+            output.append(f"[{create_time}] {sender}:")
+            output.append(f"  {text_content}")
+            output.append(f"  (Message ID: {msg_name})\n")
+
+        return "\n".join(output)
+
+    except HttpError as error:
+        logger.error(f"[get_messages] API error for space {space_id}: {error}", exc_info=True)
+        raise Exception(f"API error accessing space {space_id}: {error}")
+    except Exception as e:
+        logger.exception(f"[get_messages] Unexpected error for space {space_id}: {e}")
+        raise Exception(f"Unexpected error accessing space {space_id}: {e}")
+
+@server.tool()
+@require_google_service("chat", "chat_write")
+async def send_message(
+    service,
+    user_google_email: str,
+    space_id: str,
+    message_text: str,
+    thread_key: Optional[str] = None
+) -> str:
+    """
+    Sends a message to a Google Chat space.
+
+    Returns:
+        str: Confirmation message with sent message details.
+    """
+    logger.info(f"[send_message] Email: '{user_google_email}', Space: '{space_id}'")
+
+    try:
+        message_body = {
+            'text': message_text
+        }
+
+        # Add thread key if provided (for threaded replies)
+        request_params = {
+            'parent': space_id,
+            'body': message_body
+        }
+        if thread_key:
+            request_params['threadKey'] = thread_key
+
+        message = await asyncio.to_thread(
+            service.spaces().messages().create(**request_params).execute
+        )
+
+        message_name = message.get('name', '')
+        create_time = message.get('createTime', '')
+
+        msg = f"Message sent to space '{space_id}' by {user_google_email}. Message ID: {message_name}, Time: {create_time}"
+        logger.info(f"Successfully sent message to space '{space_id}' by {user_google_email}")
+        return msg
+
+    except HttpError as e:
+        logger.error(f"API error in send_message: {e}", exc_info=True)
+        raise Exception(f"API error: {e}")
+    except Exception as e:
+        logger.exception(f"Unexpected error in send_message: {e}")
+        raise Exception(f"Unexpected error: {e}")
+
+@server.tool()
+@require_google_service("chat", "chat_read")
+async def search_messages(
+    service,
+    user_google_email: str,
+    query: str,
+    space_id: Optional[str] = None,
+    page_size: int = 25
+) -> str:
+    """
+    Searches for messages in Google Chat spaces by text content.
+
+    Returns:
+        str: A formatted list of messages matching the search query.
+    """
+    logger.info(f"[search_messages] Email={user_google_email}, Query='{query}'")
+
+    try:
+        # If specific space provided, search within that space
+        if space_id:
+            response = await asyncio.to_thread(
+                service.spaces().messages().list(
+                    parent=space_id,
+                    pageSize=page_size,
+                    filter=f'text:"{query}"'
+                ).execute
+            )
+            messages = response.get('messages', [])
+            context = f"space '{space_id}'"
+        else:
+            # Search across all accessible spaces (this may require iterating through spaces)
+            # For simplicity, we'll search the user's spaces first
+            spaces_response = await asyncio.to_thread(
+                service.spaces().list(pageSize=100).execute
+            )
+            spaces = spaces_response.get('spaces', [])
+
+            messages = []
+            for space in spaces[:10]:  # Limit to first 10 spaces to avoid timeout
+                try:
+                    space_messages = await asyncio.to_thread(
+                        service.spaces().messages().list(
+                            parent=space.get('name'),
+                            pageSize=5,
+                            filter=f'text:"{query}"'
+                        ).execute
+                    )
+                    space_msgs = space_messages.get('messages', [])
+                    for msg in space_msgs:
+                        msg['_space_name'] = space.get('displayName', 'Unknown')
+                    messages.extend(space_msgs)
+                except HttpError:
+                    continue  # Skip spaces we can't access
+            context = "all accessible spaces"
+
+        if not messages:
+            return f"No messages found matching '{query}' in {context}."
+
+        output = [f"Found {len(messages)} messages matching '{query}' in {context}:"]
+        for msg in messages:
+            sender = msg.get('sender', {}).get('displayName', 'Unknown Sender')
+            create_time = msg.get('createTime', 'Unknown Time')
+            text_content = msg.get('text', 'No text content')
+            space_name = msg.get('_space_name', 'Unknown Space')
+
+            # Truncate long messages
+            if len(text_content) > 100:
+                text_content = text_content[:100] + "..."
+
+            output.append(f"- [{create_time}] {sender} in '{space_name}': {text_content}")
+
+        return "\n".join(output)
+
+    except HttpError as e:
+        logger.error(f"API error in search_messages: {e}", exc_info=True)
+        raise Exception(f"API error: {e}")
+    except Exception as e:
+        logger.exception(f"Unexpected error in search_messages: {e}")
+        raise Exception(f"Unexpected error: {e}")

gdocs/docs_tools.py

@@ -0,0 +1,244 @@
+"""
+Google Docs MCP Tools
+
+This module provides MCP tools for interacting with Google Docs API and managing Google Docs via Drive.
+"""
+import logging
+import asyncio
+import io
+from typing import List
+
+from mcp import types
+from googleapiclient.errors import HttpError
+from googleapiclient.http import MediaIoBaseDownload
+
+# Auth & server utilities
+from auth.service_decorator import require_google_service, require_multiple_services
+from core.utils import extract_office_xml_text
+from core.server import server
+
+logger = logging.getLogger(__name__)
+
+@server.tool()
+@require_google_service("drive", "drive_read")
+async def search_docs(
+    service,
+    user_google_email: str,
+    query: str,
+    page_size: int = 10,
+) -> str:
+    """
+    Searches for Google Docs by name using Drive API (mimeType filter).
+
+    Returns:
+        str: A formatted list of Google Docs matching the search query.
+    """
+    logger.info(f"[search_docs] Email={user_google_email}, Query='{query}'")
+
+    try:
+        escaped_query = query.replace("'", "\\'")
+
+        response = await asyncio.to_thread(
+            service.files().list(
+                q=f"name contains '{escaped_query}' and mimeType='application/vnd.google-apps.document' and trashed=false",
+                pageSize=page_size,
+                fields="files(id, name, createdTime, modifiedTime, webViewLink)"
+            ).execute
+        )
+        files = response.get('files', [])
+        if not files:
+            return f"No Google Docs found matching '{query}'."
+
+        output = [f"Found {len(files)} Google Docs matching '{query}':"]
+        for f in files:
+            output.append(
+                f"- {f['name']} (ID: {f['id']}) Modified: {f.get('modifiedTime')} Link: {f.get('webViewLink')}"
+            )
+        return "\n".join(output)
+
+    except HttpError as e:
+        logger.error(f"API error in search_docs: {e}", exc_info=True)
+        raise Exception(f"API error: {e}")
+
+@server.tool()
+@require_multiple_services([
+    {"service_type": "drive", "scopes": "drive_read", "param_name": "drive_service"},
+    {"service_type": "docs", "scopes": "docs_read", "param_name": "docs_service"}
+])
+async def get_doc_content(
+    drive_service,
+    docs_service,
+    user_google_email: str,
+    document_id: str,
+) -> str:
+    """
+    Retrieves content of a Google Doc or a Drive file (like .docx) identified by document_id.
+    - Native Google Docs: Fetches content via Docs API.
+    - Office files (.docx, etc.) stored in Drive: Downloads via Drive API and extracts text.
+
+    Returns:
+        str: The document content with metadata header.
+    """
+    logger.info(f"[get_doc_content] Invoked. Document/File ID: '{document_id}' for user '{user_google_email}'")
+
+    try:
+        # Step 2: Get file metadata from Drive
+        file_metadata = await asyncio.to_thread(
+            drive_service.files().get(
+                fileId=document_id, fields="id, name, mimeType, webViewLink"
+            ).execute
+        )
+        mime_type = file_metadata.get("mimeType", "")
+        file_name = file_metadata.get("name", "Unknown File")
+        web_view_link = file_metadata.get("webViewLink", "#")
+
+        logger.info(f"[get_doc_content] File '{file_name}' (ID: {document_id}) has mimeType: '{mime_type}'")
+
+        body_text = "" # Initialize body_text
+
+        # Step 3: Process based on mimeType
+        if mime_type == "application/vnd.google-apps.document":
+            logger.info(f"[get_doc_content] Processing as native Google Doc.")
+            doc_data = await asyncio.to_thread(
+                docs_service.documents().get(documentId=document_id).execute
+            )
+            body_elements = doc_data.get('body', {}).get('content', [])
+
+            processed_text_lines: List[str] = []
+            for element in body_elements:
+                if 'paragraph' in element:
+                    paragraph = element.get('paragraph', {})
+                    para_elements = paragraph.get('elements', [])
+                    current_line_text = ""
+                    for pe in para_elements:
+                        text_run = pe.get('textRun', {})
+                        if text_run and 'content' in text_run:
+                            current_line_text += text_run['content']
+                    if current_line_text.strip():
+                         processed_text_lines.append(current_line_text)
+            body_text = "".join(processed_text_lines)
+        else:
+            logger.info(f"[get_doc_content] Processing as Drive file (e.g., .docx, other). MimeType: {mime_type}")
+
+            export_mime_type_map = {
+                 # Example: "application/vnd.google-apps.spreadsheet"z: "text/csv",
+                 # Native GSuite types that are not Docs would go here if this function
+                 # was intended to export them. For .docx, direct download is used.
+            }
+            effective_export_mime = export_mime_type_map.get(mime_type)
+
+            request_obj = (
+                drive_service.files().export_media(fileId=document_id, mimeType=effective_export_mime)
+                if effective_export_mime
+                else drive_service.files().get_media(fileId=document_id)
+            )
+
+            fh = io.BytesIO()
+            downloader = MediaIoBaseDownload(fh, request_obj)
+            loop = asyncio.get_event_loop()
+            done = False
+            while not done:
+                status, done = await loop.run_in_executor(None, downloader.next_chunk)
+
+            file_content_bytes = fh.getvalue()
+
+            office_text = extract_office_xml_text(file_content_bytes, mime_type)
+            if office_text:
+                body_text = office_text
+            else:
+                try:
+                    body_text = file_content_bytes.decode("utf-8")
+                except UnicodeDecodeError:
+                    body_text = (
+                        f"[Binary or unsupported text encoding for mimeType '{mime_type}' - "
+                        f"{len(file_content_bytes)} bytes]"
+                    )
+
+        header = (
+            f'File: "{file_name}" (ID: {document_id}, Type: {mime_type})\n'
+            f'Link: {web_view_link}\n\n--- CONTENT ---\n'
+        )
+        return header + body_text
+
+    except HttpError as error:
+        logger.error(
+            f"[get_doc_content] API error for ID {document_id}: {error}",
+            exc_info=True,
+        )
+        raise Exception(f"API error processing document/file ID {document_id}: {error}")
+    except Exception as e:
+        logger.exception(f"[get_doc_content] Unexpected error for ID {document_id}: {e}")
+        raise Exception(f"Unexpected error processing document/file ID {document_id}: {e}")
+
+@server.tool()
+@require_google_service("drive", "drive_read")
+async def list_docs_in_folder(
+    service,
+    user_google_email: str,
+    folder_id: str = 'root',
+    page_size: int = 100
+) -> str:
+    """
+    Lists Google Docs within a specific Drive folder.
+
+    Returns:
+        str: A formatted list of Google Docs in the specified folder.
+    """
+    logger.info(f"[list_docs_in_folder] Invoked. Email: '{user_google_email}', Folder ID: '{folder_id}'")
+
+    try:
+        rsp = await asyncio.to_thread(
+            service.files().list(
+                q=f"'{folder_id}' in parents and mimeType='application/vnd.google-apps.document' and trashed=false",
+                pageSize=page_size,
+                fields="files(id, name, modifiedTime, webViewLink)"
+            ).execute
+        )
+        items = rsp.get('files', [])
+        if not items:
+            return f"No Google Docs found in folder '{folder_id}'."
+        out = [f"Found {len(items)} Docs in folder '{folder_id}':"]
+        for f in items:
+            out.append(f"- {f['name']} (ID: {f['id']}) Modified: {f.get('modifiedTime')} Link: {f.get('webViewLink')}")
+        return "\n".join(out)
+
+    except HttpError as e:
+        logger.error(f"API error in list_docs_in_folder: {e}", exc_info=True)
+        raise Exception(f"API error: {e}")
+    except Exception as e:
+        logger.exception(f"Unexpected error in list_docs_in_folder: {e}")
+        raise Exception(f"Unexpected error: {e}")
+
+@server.tool()
+@require_google_service("docs", "docs_write")
+async def create_doc(
+    service,
+    user_google_email: str, # Made user_google_email required
+    title: str,
+    content: str = '',
+) -> str:
+    """
+    Creates a new Google Doc and optionally inserts initial content.
+
+    Returns:
+        str: Confirmation message with document ID and link.
+    """
+    logger.info(f"[create_doc] Invoked. Email: '{user_google_email}', Title='{title}'")
+
+    try:
+        doc = await asyncio.to_thread(service.documents().create(body={'title': title}).execute)
+        doc_id = doc.get('documentId')
+        if content:
+            requests = [{'insertText': {'location': {'index': 1}, 'text': content}}]
+            await asyncio.to_thread(service.documents().batchUpdate(documentId=doc_id, body={'requests': requests}).execute)
+        link = f"https://docs.google.com/document/d/{doc_id}/edit"
+        msg = f"Created Google Doc '{title}' (ID: {doc_id}) for {user_google_email}. Link: {link}"
+        logger.info(f"Successfully created Google Doc '{title}' (ID: {doc_id}) for {user_google_email}. Link: {link}")
+        return msg
+
+    except HttpError as e:
+        logger.error(f"API error in create_doc: {e}", exc_info=True)
+        raise Exception(f"API error: {e}")
+    except Exception as e:
+        logger.exception(f"Unexpected error in create_doc: {e}")
+        raise Exception(f"Unexpected error: {e}")