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

auth/google_auth.py

@@ -27,7 +27,7 @@ DEFAULT_CREDENTIALS_DIR = ".credentials"
 # This should be more robust in a production system once OAuth2.1 is implemented in client.
 _SESSION_CREDENTIALS_CACHE: Dict[str, Credentials] = {}
 # Centralized Client Secrets Path Logic
-_client_secrets_env = os.getenv("GOOGLE_CLIENT_SECRETS")
+_client_secrets_env = os.getenv("GOOGLE_CLIENT_SECRET_PATH") or os.getenv("GOOGLE_CLIENT_SECRETS")
 if _client_secrets_env:
     CONFIG_CLIENT_SECRETS_PATH = _client_secrets_env
 else:
@@ -151,22 +151,128 @@ def load_credentials_from_session(session_id: str) -> Optional[Credentials]:
         logger.debug(f"No credentials found in session cache for session_id: {session_id}")
     return credentials
 
+def load_client_secrets_from_env() -> Optional[Dict[str, Any]]:
+    """
+    Loads the client secrets from environment variables.
+
+    Environment variables used:
+        - GOOGLE_OAUTH_CLIENT_ID: OAuth 2.0 client ID
+        - GOOGLE_OAUTH_CLIENT_SECRET: OAuth 2.0 client secret
+        - GOOGLE_OAUTH_REDIRECT_URI: (optional) OAuth redirect URI
+
+    Returns:
+        Client secrets configuration dict compatible with Google OAuth library,
+        or None if required environment variables are not set.
+    """
+    client_id = os.getenv("GOOGLE_OAUTH_CLIENT_ID")
+    client_secret = os.getenv("GOOGLE_OAUTH_CLIENT_SECRET")
+    redirect_uri = os.getenv("GOOGLE_OAUTH_REDIRECT_URI")
+
+    if client_id and client_secret:
+        # Create config structure that matches Google client secrets format
+        web_config = {
+            "client_id": client_id,
+            "client_secret": client_secret,
+            "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+            "token_uri": "https://oauth2.googleapis.com/token",
+            "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs"
+        }
+
+        # Add redirect_uri if provided via environment variable
+        if redirect_uri:
+            web_config["redirect_uris"] = [redirect_uri]
+
+        # Return the full config structure expected by Google OAuth library
+        config = {"web": web_config}
+
+        logger.info("Loaded OAuth client credentials from environment variables")
+        return config
+
+    logger.debug("OAuth client credentials not found in environment variables")
+    return None
+
 def load_client_secrets(client_secrets_path: str) -> Dict[str, Any]:
-    """Loads the client secrets file."""
+    """
+    Loads the client secrets from environment variables (preferred) or from the client secrets file.
+
+    Priority order:
+    1. Environment variables (GOOGLE_OAUTH_CLIENT_ID, GOOGLE_OAUTH_CLIENT_SECRET)
+    2. File-based credentials at the specified path
+
+    Args:
+        client_secrets_path: Path to the client secrets JSON file (used as fallback)
+
+    Returns:
+        Client secrets configuration dict
+
+    Raises:
+        ValueError: If client secrets file has invalid format
+        IOError: If file cannot be read and no environment variables are set
+    """
+    # First, try to load from environment variables
+    env_config = load_client_secrets_from_env()
+    if env_config:
+        # Extract the "web" config from the environment structure
+        return env_config["web"]
+
+    # Fall back to loading from file
     try:
         with open(client_secrets_path, 'r') as f:
             client_config = json.load(f)
             # The file usually contains a top-level key like "web" or "installed"
             if "web" in client_config:
+                logger.info(f"Loaded OAuth client credentials from file: {client_secrets_path}")
                 return client_config["web"]
             elif "installed" in client_config:
-                 return client_config["installed"]
+                logger.info(f"Loaded OAuth client credentials from file: {client_secrets_path}")
+                return client_config["installed"]
             else:
                  logger.error(f"Client secrets file {client_secrets_path} has unexpected format.")
                  raise ValueError("Invalid client secrets file format")
     except (IOError, json.JSONDecodeError) as e:
         logger.error(f"Error loading client secrets file {client_secrets_path}: {e}")
         raise
+def check_client_secrets() -> Optional[str]:
+    """
+    Checks for the presence of OAuth client secrets, either as environment
+    variables or as a file.
+
+    Returns:
+        An error message string if secrets are not found, otherwise None.
+    """
+    env_config = load_client_secrets_from_env()
+    if not env_config and not os.path.exists(CONFIG_CLIENT_SECRETS_PATH):
+        logger.error(f"OAuth client credentials not found. No environment variables set and no file at {CONFIG_CLIENT_SECRETS_PATH}")
+        return f"OAuth client credentials not found. Please set GOOGLE_OAUTH_CLIENT_ID and GOOGLE_OAUTH_CLIENT_SECRET environment variables or provide a client secrets file at {CONFIG_CLIENT_SECRETS_PATH}."
+    return None
+
+def create_oauth_flow(scopes: List[str], redirect_uri: str, state: Optional[str] = None) -> Flow:
+    """Creates an OAuth flow using environment variables or client secrets file."""
+    # Try environment variables first
+    env_config = load_client_secrets_from_env()
+    if env_config:
+        # Use client config directly
+        flow = Flow.from_client_config(
+            env_config,
+            scopes=scopes,
+            redirect_uri=redirect_uri,
+            state=state
+        )
+        logger.debug("Created OAuth flow from environment variables")
+        return flow
+
+    # Fall back to file-based config
+    if not os.path.exists(CONFIG_CLIENT_SECRETS_PATH):
+        raise FileNotFoundError(f"OAuth client secrets file not found at {CONFIG_CLIENT_SECRETS_PATH} and no environment variables set")
+
+    flow = Flow.from_client_secrets_file(
+        CONFIG_CLIENT_SECRETS_PATH,
+        scopes=scopes,
+        redirect_uri=redirect_uri,
+        state=state
+    )
+    logger.debug(f"Created OAuth flow from client secrets file: {CONFIG_CLIENT_SECRETS_PATH}")
+    return flow
 
 # --- Core OAuth Logic ---
 
@@ -206,8 +312,7 @@ async def start_auth_flow(
             OAUTH_STATE_TO_SESSION_ID_MAP[oauth_state] = mcp_session_id
             logger.info(f"[start_auth_flow] Stored mcp_session_id '{mcp_session_id}' for oauth_state '{oauth_state}'.")
 
-        flow = Flow.from_client_secrets_file(
-            CONFIG_CLIENT_SECRETS_PATH, # Use module constant
+        flow = create_oauth_flow(
             scopes=SCOPES, # Use global SCOPES
             redirect_uri=redirect_uri, # Use passed redirect_uri
             state=oauth_state
@@ -240,7 +345,7 @@ async def start_auth_flow(
         return "\n".join(message_lines)
 
     except FileNotFoundError as e:
-        error_text = f"OAuth client secrets file not found: {e}. Please ensure '{CONFIG_CLIENT_SECRETS_PATH}' is correctly configured."
+        error_text = f"OAuth client credentials not found: {e}. Please either:\n1. Set environment variables: GOOGLE_OAUTH_CLIENT_ID and GOOGLE_OAUTH_CLIENT_SECRET\n2. Ensure '{CONFIG_CLIENT_SECRETS_PATH}' file exists"
         logger.error(error_text, exc_info=True)
         raise Exception(error_text)
     except Exception as e:
@@ -249,12 +354,12 @@ async def start_auth_flow(
         raise Exception(error_text)
 
 def handle_auth_callback(
-    client_secrets_path: str,
     scopes: List[str],
     authorization_response: str,
-    redirect_uri: str, # Made redirect_uri a required parameter
+    redirect_uri: str,
     credentials_base_dir: str = DEFAULT_CREDENTIALS_DIR,
-    session_id: Optional[str] = None
+    session_id: Optional[str] = None,
+    client_secrets_path: Optional[str] = None  # Deprecated: kept for backward compatibility
 ) -> Tuple[str, Credentials]:
     """
     Handles the callback from Google, exchanges the code for credentials,
@@ -262,12 +367,12 @@ def handle_auth_callback(
     and returns them.
 
     Args:
-        client_secrets_path: Path to the Google client secrets JSON file.
         scopes: List of OAuth scopes requested.
         authorization_response: The full callback URL from Google.
         redirect_uri: The redirect URI.
         credentials_base_dir: Base directory for credential files.
         session_id: Optional MCP session ID to associate with the credentials.
+        client_secrets_path: (Deprecated) Path to client secrets file. Ignored if environment variables are set.
 
     Returns:
         A tuple containing the user_google_email and the obtained Credentials object.
@@ -278,13 +383,16 @@ def handle_auth_callback(
         HttpError: If fetching user info fails.
     """
     try:
+        # Log deprecation warning if old parameter is used
+        if client_secrets_path:
+            logger.warning("The 'client_secrets_path' parameter is deprecated. Use GOOGLE_OAUTH_CLIENT_ID and GOOGLE_OAUTH_CLIENT_SECRET environment variables instead.")
+
         # Allow HTTP for localhost in development
         if 'OAUTHLIB_INSECURE_TRANSPORT' not in os.environ:
             logger.warning("OAUTHLIB_INSECURE_TRANSPORT not set. Setting it for localhost development.")
             os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
 
-        flow = Flow.from_client_secrets_file(
-            client_secrets_path,
+        flow = create_oauth_flow(
             scopes=scopes,
             redirect_uri=redirect_uri
         )

auth/oauth_callback_server.py

@@ -15,7 +15,7 @@ import socket
 from fastapi import FastAPI, Request
 import uvicorn
 
-from auth.google_auth import handle_auth_callback, CONFIG_CLIENT_SECRETS_PATH
+from auth.google_auth import handle_auth_callback, check_client_secrets
 from auth.scopes import OAUTH_STATE_TO_SESSION_ID_MAP, SCOPES
 from auth.oauth_responses import create_error_response, create_success_response, create_server_error_response
 
@@ -59,6 +59,11 @@ class MinimalOAuthServer:
                 return create_error_response(error_message)
 
             try:
+                # Check if we have credentials available (environment variables or file)
+                error_message = check_client_secrets()
+                if error_message:
+                    return create_server_error_response(error_message)
+
                 logger.info(f"OAuth callback: Received code (state: {state}). Attempting to exchange for tokens.")
 
                 mcp_session_id: Optional[str] = OAUTH_STATE_TO_SESSION_ID_MAP.pop(state, None)
@@ -69,7 +74,6 @@ class MinimalOAuthServer:
 
                 # Exchange code for credentials
                 verified_user_id, credentials = handle_auth_callback(
-                    client_secrets_path=CONFIG_CLIENT_SECRETS_PATH,
                     scopes=SCOPES,
                     authorization_response=str(request.url),
                     redirect_uri=f"{self.base_uri}:{self.port}/oauth2callback",
@@ -106,7 +110,7 @@ class MinimalOAuthServer:
             hostname = parsed_uri.hostname or 'localhost'
         except Exception:
             hostname = 'localhost'
-            
+
         try:
             with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                 s.bind((hostname, self.port))

core/comments.py

@@ -0,0 +1,257 @@
+"""
+Core Comments Module
+
+This module provides reusable comment management functions for Google Workspace applications.
+All Google Workspace apps (Docs, Sheets, Slides) use the Drive API for comment operations.
+"""
+
+import logging
+import asyncio
+from typing import Dict, Any
+
+from mcp import types
+from googleapiclient.errors import HttpError
+
+from auth.service_decorator import require_google_service
+from core.server import server
+from core.utils import handle_http_errors
+
+logger = logging.getLogger(__name__)
+
+
+def create_comment_tools(app_name: str, file_id_param: str):
+    """
+    Factory function to create comment management tools for a specific Google Workspace app.
+
+    Args:
+        app_name: Name of the app (e.g., "document", "spreadsheet", "presentation")
+        file_id_param: Parameter name for the file ID (e.g., "document_id", "spreadsheet_id", "presentation_id")
+
+    Returns:
+        Dict containing the four comment management functions with unique names
+    """
+
+    # Create unique function names based on the app type
+    read_func_name = f"read_{app_name}_comments"
+    create_func_name = f"create_{app_name}_comment"
+    reply_func_name = f"reply_to_{app_name}_comment"
+    resolve_func_name = f"resolve_{app_name}_comment"
+
+    # Create read comments function
+    if file_id_param == "document_id":
+        @server.tool()
+        @require_google_service("drive", "drive_read")
+        @handle_http_errors(read_func_name)
+        async def read_comments(service, user_google_email: str, document_id: str) -> str:
+            """Read all comments from a Google Slide, Sheet or Doc."""
+            return await _read_comments_impl(service, app_name, document_id)
+
+        @server.tool()
+        @require_google_service("drive", "drive_file")
+        @handle_http_errors(create_func_name)
+        async def create_comment(service, user_google_email: str, document_id: str, comment_content: str) -> str:
+            """Create a new comment on a Google Slide, Sheet or Doc."""
+            return await _create_comment_impl(service, app_name, document_id, comment_content)
+
+        @server.tool()
+        @require_google_service("drive", "drive_file")
+        @handle_http_errors(reply_func_name)
+        async def reply_to_comment(service, user_google_email: str, document_id: str, comment_id: str, reply_content: str) -> str:
+            """Reply to a specific comment in a Google Document."""
+            return await _reply_to_comment_impl(service, app_name, document_id, comment_id, reply_content)
+
+        @server.tool()
+        @require_google_service("drive", "drive_file")
+        @handle_http_errors(resolve_func_name)
+        async def resolve_comment(service, user_google_email: str, document_id: str, comment_id: str) -> str:
+            """Resolve a comment in a Google Slide, Sheet or Doc."""
+            return await _resolve_comment_impl(service, app_name, document_id, comment_id)
+
+    elif file_id_param == "spreadsheet_id":
+        @server.tool()
+        @require_google_service("drive", "drive_read")
+        @handle_http_errors(read_func_name)
+        async def read_comments(service, user_google_email: str, spreadsheet_id: str) -> str:
+            """Read all comments from a Google Slide, Sheet or Doc."""
+            return await _read_comments_impl(service, app_name, spreadsheet_id)
+
+        @server.tool()
+        @require_google_service("drive", "drive_file")
+        @handle_http_errors(create_func_name)
+        async def create_comment(service, user_google_email: str, spreadsheet_id: str, comment_content: str) -> str:
+            """Create a new comment on a Google Slide, Sheet or Doc."""
+            return await _create_comment_impl(service, app_name, spreadsheet_id, comment_content)
+
+        @server.tool()
+        @require_google_service("drive", "drive_file")
+        @handle_http_errors(reply_func_name)
+        async def reply_to_comment(service, user_google_email: str, spreadsheet_id: str, comment_id: str, reply_content: str) -> str:
+            """Reply to a specific comment in a Google Slide, Sheet or Doc."""
+            return await _reply_to_comment_impl(service, app_name, spreadsheet_id, comment_id, reply_content)
+
+        @server.tool()
+        @require_google_service("drive", "drive_file")
+        @handle_http_errors(resolve_func_name)
+        async def resolve_comment(service, user_google_email: str, spreadsheet_id: str, comment_id: str) -> str:
+            """Resolve a comment in a Google Slide, Sheet or Doc."""
+            return await _resolve_comment_impl(service, app_name, spreadsheet_id, comment_id)
+
+    elif file_id_param == "presentation_id":
+        @server.tool()
+        @require_google_service("drive", "drive_read")
+        @handle_http_errors(read_func_name)
+        async def read_comments(service, user_google_email: str, presentation_id: str) -> str:
+            """Read all comments from a Google Slide, Sheet or Doc."""
+            return await _read_comments_impl(service, app_name, presentation_id)
+
+        @server.tool()
+        @require_google_service("drive", "drive_file")
+        @handle_http_errors(create_func_name)
+        async def create_comment(service, user_google_email: str, presentation_id: str, comment_content: str) -> str:
+            """Create a new comment on a Google Slide, Sheet or Doc."""
+            return await _create_comment_impl(service, app_name, presentation_id, comment_content)
+
+        @server.tool()
+        @require_google_service("drive", "drive_file")
+        @handle_http_errors(reply_func_name)
+        async def reply_to_comment(service, user_google_email: str, presentation_id: str, comment_id: str, reply_content: str) -> str:
+            """Reply to a specific comment in a Google Slide, Sheet or Doc."""
+            return await _reply_to_comment_impl(service, app_name, presentation_id, comment_id, reply_content)
+
+        @server.tool()
+        @require_google_service("drive", "drive_file")
+        @handle_http_errors(resolve_func_name)
+        async def resolve_comment(service, user_google_email: str, presentation_id: str, comment_id: str) -> str:
+            """Resolve a comment in a Google Slide, Sheet or Doc."""
+            return await _resolve_comment_impl(service, app_name, presentation_id, comment_id)
+
+    # Set the proper function names for MCP registration
+    read_comments.__name__ = read_func_name
+    create_comment.__name__ = create_func_name
+    reply_to_comment.__name__ = reply_func_name
+    resolve_comment.__name__ = resolve_func_name
+
+    return {
+        'read_comments': read_comments,
+        'create_comment': create_comment,
+        'reply_to_comment': reply_to_comment,
+        'resolve_comment': resolve_comment
+    }
+
+
+async def _read_comments_impl(service, app_name: str, file_id: str) -> str:
+    """Implementation for reading comments from any Google Workspace file."""
+    logger.info(f"[read_{app_name}_comments] Reading comments for {app_name} {file_id}")
+
+    response = await asyncio.to_thread(
+        service.comments().list(
+            fileId=file_id,
+            fields="comments(id,content,author,createdTime,modifiedTime,resolved,replies(content,author,id,createdTime,modifiedTime))"
+        ).execute
+    )
+
+    comments = response.get('comments', [])
+
+    if not comments:
+        return f"No comments found in {app_name} {file_id}"
+
+    output = [f"Found {len(comments)} comments in {app_name} {file_id}:\\n"]
+
+    for comment in comments:
+        author = comment.get('author', {}).get('displayName', 'Unknown')
+        content = comment.get('content', '')
+        created = comment.get('createdTime', '')
+        resolved = comment.get('resolved', False)
+        comment_id = comment.get('id', '')
+        status = " [RESOLVED]" if resolved else ""
+
+        output.append(f"Comment ID: {comment_id}")
+        output.append(f"Author: {author}")
+        output.append(f"Created: {created}{status}")
+        output.append(f"Content: {content}")
+
+        # Add replies if any
+        replies = comment.get('replies', [])
+        if replies:
+            output.append(f"  Replies ({len(replies)}):")
+            for reply in replies:
+                reply_author = reply.get('author', {}).get('displayName', 'Unknown')
+                reply_content = reply.get('content', '')
+                reply_created = reply.get('createdTime', '')
+                reply_id = reply.get('id', '')
+                output.append(f"    Reply ID: {reply_id}")
+                output.append(f"    Author: {reply_author}")
+                output.append(f"    Created: {reply_created}")
+                output.append(f"    Content: {reply_content}")
+
+        output.append("")  # Empty line between comments
+
+    return "\\n".join(output)
+
+
+async def _create_comment_impl(service, app_name: str, file_id: str, comment_content: str) -> str:
+    """Implementation for creating a comment on any Google Workspace file."""
+    logger.info(f"[create_{app_name}_comment] Creating comment in {app_name} {file_id}")
+
+    body = {"content": comment_content}
+
+    comment = await asyncio.to_thread(
+        service.comments().create(
+            fileId=file_id,
+            body=body,
+            fields="id,content,author,createdTime,modifiedTime"
+        ).execute
+    )
+
+    comment_id = comment.get('id', '')
+    author = comment.get('author', {}).get('displayName', 'Unknown')
+    created = comment.get('createdTime', '')
+
+    return f"Comment created successfully!\\nComment ID: {comment_id}\\nAuthor: {author}\\nCreated: {created}\\nContent: {comment_content}"
+
+
+async def _reply_to_comment_impl(service, app_name: str, file_id: str, comment_id: str, reply_content: str) -> str:
+    """Implementation for replying to a comment on any Google Workspace file."""
+    logger.info(f"[reply_to_{app_name}_comment] Replying to comment {comment_id} in {app_name} {file_id}")
+
+    body = {'content': reply_content}
+
+    reply = await asyncio.to_thread(
+        service.replies().create(
+            fileId=file_id,
+            commentId=comment_id,
+            body=body,
+            fields="id,content,author,createdTime,modifiedTime"
+        ).execute
+    )
+
+    reply_id = reply.get('id', '')
+    author = reply.get('author', {}).get('displayName', 'Unknown')
+    created = reply.get('createdTime', '')
+
+    return f"Reply posted successfully!\\nReply ID: {reply_id}\\nAuthor: {author}\\nCreated: {created}\\nContent: {reply_content}"
+
+
+async def _resolve_comment_impl(service, app_name: str, file_id: str, comment_id: str) -> str:
+    """Implementation for resolving a comment on any Google Workspace file."""
+    logger.info(f"[resolve_{app_name}_comment] Resolving comment {comment_id} in {app_name} {file_id}")
+
+    body = {
+        "content": "This comment has been resolved.",
+        "action": "resolve"
+    }
+
+    reply = await asyncio.to_thread(
+        service.replies().create(
+            fileId=file_id,
+            commentId=comment_id,
+            body=body,
+            fields="id,content,author,createdTime,modifiedTime"
+        ).execute
+    )
+
+    reply_id = reply.get('id', '')
+    author = reply.get('author', {}).get('displayName', 'Unknown')
+    created = reply.get('createdTime', '')
+
+    return f"Comment {comment_id} has been resolved successfully.\\nResolve reply ID: {reply_id}\\nAuthor: {author}\\nCreated: {created}"

core/context.py

@@ -0,0 +1,22 @@
+# core/context.py
+import contextvars
+from typing import Optional
+
+# Context variable to hold injected credentials for the life of a single request.
+_injected_oauth_credentials = contextvars.ContextVar(
+    "injected_oauth_credentials", default=None
+)
+
+def get_injected_oauth_credentials():
+    """
+    Retrieve injected OAuth credentials for the current request context.
+    This is called by the authentication layer to check for request-scoped credentials.
+    """
+    return _injected_oauth_credentials.get()
+
+def set_injected_oauth_credentials(credentials: Optional[dict]):
+    """
+    Set or clear the injected OAuth credentials for the current request context.
+    This is called by the service decorator.
+    """
+    _injected_oauth_credentials.set(credentials)

core/server.py

@@ -11,7 +11,7 @@ from mcp import types
 from mcp.server.fastmcp import FastMCP
 from starlette.requests import Request
 
-from auth.google_auth import handle_auth_callback, start_auth_flow, CONFIG_CLIENT_SECRETS_PATH
+from auth.google_auth import handle_auth_callback, start_auth_flow, check_client_secrets
 from auth.oauth_callback_server import get_oauth_redirect_uri, ensure_oauth_callback_available
 from auth.oauth_responses import create_error_response, create_success_response, create_server_error_response
 
@@ -58,6 +58,7 @@ logger = logging.getLogger(__name__)
 
 WORKSPACE_MCP_PORT = int(os.getenv("PORT", os.getenv("WORKSPACE_MCP_PORT", 8000)))
 WORKSPACE_MCP_BASE_URI = os.getenv("WORKSPACE_MCP_BASE_URI", "http://localhost")
+USER_GOOGLE_EMAIL = os.getenv("USER_GOOGLE_EMAIL", None)
 
 # Transport mode detection (will be set by main.py)
 _current_transport_mode = "stdio"  # Default to stdio
@@ -119,11 +120,10 @@ async def oauth2_callback(request: Request) -> HTMLResponse:
         return create_error_response(error_message)
 
     try:
-        client_secrets_path = CONFIG_CLIENT_SECRETS_PATH
-        if not os.path.exists(client_secrets_path):
-            logger.error(f"OAuth client secrets file not found at {client_secrets_path}")
-            # This is a server configuration error, should not happen in a deployed environment.
-            return HTMLResponse(content="Server Configuration Error: Client secrets not found.", status_code=500)
+        # Check if we have credentials available (environment variables or file)
+        error_message = check_client_secrets()
+        if error_message:
+            return create_server_error_response(error_message)
 
         logger.info(f"OAuth callback: Received code (state: {state}). Attempting to exchange for tokens.")
 
@@ -136,7 +136,6 @@ async def oauth2_callback(request: Request) -> HTMLResponse:
         # Exchange code for credentials. handle_auth_callback will save them.
         # The user_id returned here is the Google-verified email.
         verified_user_id, credentials = handle_auth_callback(
-            client_secrets_path=client_secrets_path,
             scopes=SCOPES, # Ensure all necessary scopes are requested
             authorization_response=str(request.url),
             redirect_uri=get_oauth_redirect_uri_for_current_mode(),
@@ -157,8 +156,8 @@ async def oauth2_callback(request: Request) -> HTMLResponse:
 
 @server.tool()
 async def start_google_auth(
-    user_google_email: str,
     service_name: str,
+    user_google_email: str = USER_GOOGLE_EMAIL,
     mcp_session_id: Optional[str] = Header(None, alias="Mcp-Session-Id")
 ) -> str:
     """

gdocs/docs_tools.py

@@ -16,6 +16,7 @@ from googleapiclient.http import MediaIoBaseDownload
 from auth.service_decorator import require_google_service, require_multiple_services
 from core.utils import extract_office_xml_text, handle_http_errors
 from core.server import server
+from core.comments import create_comment_tools
 
 logger = logging.getLogger(__name__)
 
@@ -214,3 +215,13 @@ async def create_doc(
     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
+
+
+# Create comment management tools for documents
+_comment_tools = create_comment_tools("document", "document_id")
+
+# Extract and register the functions
+read_doc_comments = _comment_tools['read_comments']
+create_doc_comment = _comment_tools['create_comment']
+reply_to_comment = _comment_tools['reply_to_comment']
+resolve_comment = _comment_tools['resolve_comment']

gsheets/sheets_tools.py

@@ -14,6 +14,7 @@ from googleapiclient.errors import HttpError
 from auth.service_decorator import require_google_service
 from core.server import server
 from core.utils import handle_http_errors
+from core.comments import create_comment_tools
 
 # Configure module logger
 logger = logging.getLogger(__name__)
@@ -338,3 +339,13 @@ async def create_sheet(
     return text_output
 
 
+# Create comment management tools for sheets
+_comment_tools = create_comment_tools("spreadsheet", "spreadsheet_id")
+
+# Extract and register the functions
+read_sheet_comments = _comment_tools['read_comments']
+create_sheet_comment = _comment_tools['create_comment'] 
+reply_to_sheet_comment = _comment_tools['reply_to_comment']
+resolve_sheet_comment = _comment_tools['resolve_comment']
+
+

gslides/slides_tools.py

@@ -14,6 +14,7 @@ from googleapiclient.errors import HttpError
 from auth.service_decorator import require_google_service
 from core.server import server
 from core.utils import handle_http_errors
+from core.comments import create_comment_tools
 
 logger = logging.getLogger(__name__)
 
@@ -269,4 +270,18 @@ async def get_page_thumbnail(
 You can view or download the thumbnail using the provided URL."""
     
     logger.info(f"Thumbnail generated successfully for {user_google_email}")
-    return confirmation_message
+    return confirmation_message
+
+
+# Create comment management tools for slides
+_comment_tools = create_comment_tools("presentation", "presentation_id")
+read_presentation_comments = _comment_tools['read_comments']
+create_presentation_comment = _comment_tools['create_comment']
+reply_to_presentation_comment = _comment_tools['reply_to_comment']
+resolve_presentation_comment = _comment_tools['resolve_comment']
+
+# Aliases for backwards compatibility and intuitive naming
+read_slide_comments = read_presentation_comments
+create_slide_comment = create_presentation_comment
+reply_to_slide_comment = reply_to_presentation_comment
+resolve_slide_comment = resolve_presentation_comment

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workspace-mcp
-Version: 1.0.2
+Version: 1.0.4
 Summary: Comprehensive, highly performant Google Workspace Streamable HTTP & SSE MCP Server for Calendar, Gmail, Docs, Sheets, Slides & Drive
 Author-email: Taylor Wilsdon <taylor@taylorwilsdon.com>
 License: MIT
@@ -76,6 +76,14 @@ Dynamic: license-file
 
 ---
 
+### A quick plug for AI-Enhanced Docs
+
+> **This README was crafted with AI assistance, and here's why that matters**
+> 
+> As a solo developer building open source tools that may only ever serve my own needs, comprehensive documentation often wouldn't happen without AI help. Using agentic dev tools like **Roo** & **Claude Code** that understand the entire codebase, AI doesn't just regurgitate generic content - it extracts real implementation details and creates accurate, specific documentation.
+>
+> In this case, Sonnet 4 took a pass & a human (me) verified them 6/28/25.
+
 
 ## 🌐 Overview
 
@@ -87,9 +95,9 @@ A production-ready MCP server that integrates all major Google Workspace service
 - **📅 Google Calendar**: Full calendar management with event CRUD operations
 - **📁 Google Drive**: File operations with native Microsoft Office format support (.docx, .xlsx)
 - **📧 Gmail**: Complete email management with search, send, and draft capabilities
-- **📄 Google Docs**: Document operations including content extraction and creation
-- **📊 Google Sheets**: Comprehensive spreadsheet management with flexible cell operations
-- **🖼️ Google Slides**: Presentation management with slide creation, updates, and content manipulation
+- **📄 Google Docs**: Document operations including content extraction, creation, and comment management
+- **📊 Google Sheets**: Comprehensive spreadsheet management with flexible cell operations and comment management
+- **🖼️ Google Slides**: Presentation management with slide creation, updates, content manipulation, and comment management
 - **📝 Google Forms**: Form creation, retrieval, publish settings, and response management
 - **💬 Google Chat**: Space management and messaging capabilities
 - **🔄 Multiple Transports**: HTTP with SSE fallback, OpenAPI compatibility via `mcpo`
@@ -102,9 +110,13 @@ A production-ready MCP server that integrates all major Google Workspace service
 
 ### Simplest Start (uvx - Recommended)
 
-Run instantly without installation:
+> Run instantly without manual installation - you must configure OAuth credentials when using uvx. You can use either environment variables (recommended for production) or set the `GOOGLE_CLIENT_SECRET_PATH` (or legacy `GOOGLE_CLIENT_SECRETS`) environment variable to point to your `client_secret.json` file.
 
 ```bash
+# Set OAuth credentials via environment variables (recommended)
+export GOOGLE_OAUTH_CLIENT_ID="your-client-id.apps.googleusercontent.com"
+export GOOGLE_OAUTH_CLIENT_SECRET="your-client-secret"
+
 # Start the server with all Google Workspace tools
 uvx workspace-mcp
 
@@ -138,19 +150,43 @@ uv run main.py
 1. **Google Cloud Setup**:
    - Create OAuth 2.0 credentials (web application) in [Google Cloud Console](https://console.cloud.google.com/)
    - Enable APIs: Calendar, Drive, Gmail, Docs, Sheets, Slides, Forms, Chat
-   - Download credentials as `client_secret.json` in project root
-     - To use a different location for `client_secret.json`, you can set the `GOOGLE_CLIENT_SECRETS` environment variable with that path
    - Add redirect URI: `http://localhost:8000/oauth2callback`
+   - Configure credentials using one of these methods:
+
+     **Option A: Environment Variables (Recommended for Production)**
+     ```bash
+     export GOOGLE_OAUTH_CLIENT_ID="your-client-id.apps.googleusercontent.com"
+     export GOOGLE_OAUTH_CLIENT_SECRET="your-client-secret"
+     export GOOGLE_OAUTH_REDIRECT_URI="http://localhost:8000/oauth2callback"  # Optional
+     ```
+
+     **Option B: File-based (Traditional)**
+     - Download credentials as `client_secret.json` in project root
+     - To use a different location, set `GOOGLE_CLIENT_SECRET_PATH` (or legacy `GOOGLE_CLIENT_SECRETS`) environment variable with the file path
+
+   **Credential Loading Priority**:
+   1. Environment variables (`GOOGLE_OAUTH_CLIENT_ID`, `GOOGLE_OAUTH_CLIENT_SECRET`)
+   2. File specified by `GOOGLE_CLIENT_SECRET_PATH` or `GOOGLE_CLIENT_SECRETS` environment variable
+   3. Default file (`client_secret.json` in project root)
+
+   **Why Environment Variables?**
+   - ✅ Containerized deployments (Docker, Kubernetes)
+   - ✅ Cloud platforms (Heroku, Railway, etc.)
+   - ✅ CI/CD pipelines
+   - ✅ No secrets in version control
+   - ✅ Easy credential rotation
 
 2. **Environment**:
    ```bash
    export OAUTHLIB_INSECURE_TRANSPORT=1  # Development only
+   export USER_GOOGLE_EMAIL=your.email@gmail.com  # Optional: Default email for auth - use this for single user setups and you won't need to set your email in system prompt for magic auth
    ```
 
 3. **Server Configuration**:
    The server's base URL and port can be customized using environment variables:
    - `WORKSPACE_MCP_BASE_URI`: Sets the base URI for the server (default: http://localhost). This affects the server_url used for Gemini native function calling and the OAUTH_REDIRECT_URI.
    - `WORKSPACE_MCP_PORT`: Sets the port the server listens on (default: 8000). This affects the server_url, port, and OAUTH_REDIRECT_URI.
+   - `USER_GOOGLE_EMAIL`: Optional default email for authentication flows. If set, the LLM won't need to specify your email when calling `start_google_auth`.
 
 ### Start the Server
 
@@ -198,7 +234,11 @@ python install_claude.py
   "mcpServers": {
     "google_workspace": {
       "command": "uvx",
-      "args": ["workspace-mcp"]
+      "args": ["workspace-mcp"],
+      "env": {
+        "GOOGLE_OAUTH_CLIENT_ID": "your-client-id.apps.googleusercontent.com",
+        "GOOGLE_OAUTH_CLIENT_SECRET": "your-client-secret"
+      }
     }
   }
 }
@@ -211,7 +251,11 @@ python install_claude.py
     "google_workspace": {
       "command": "uv",
       "args": ["run", "main.py"],
-      "cwd": "/path/to/google_workspace_mcp"
+      "cwd": "/path/to/google_workspace_mcp",
+      "env": {
+        "GOOGLE_OAUTH_CLIENT_ID": "your-client-id.apps.googleusercontent.com",
+        "GOOGLE_OAUTH_CLIENT_SECRET": "your-client-secret"
+      }
     }
   }
 }
@@ -259,7 +303,8 @@ When calling a tool:
 |------|-------------|
 | `list_calendars` | List accessible calendars |
 | `get_events` | Retrieve events with time range filtering |
-| `create_event` | Create events (all-day or timed) |
+| `get_event` | Fetch detailed information of a single event by ID |
+| `create_event` | Create events (all-day or timed) with optional Drive file attachments |
 | `modify_event` | Update existing events |
 | `delete_event` | Remove events |
 
@@ -270,7 +315,7 @@ When calling a tool:
 | `search_drive_files` | Search files with query syntax |
 | `get_drive_file_content` | Read file content (supports Office formats) |
 | `list_drive_items` | List folder contents |
-| `create_drive_file` | Create new files |
+| `create_drive_file` | Create new files or fetch content from public URLs |
 
 ### 📧 Gmail ([`gmail_tools.py`](gmail/gmail_tools.py))
 
@@ -289,6 +334,10 @@ When calling a tool:
 | `get_doc_content` | Extract document text |
 | `list_docs_in_folder` | List docs in folder |
 | `create_doc` | Create new documents |
+| `read_doc_comments` | Read all comments and replies |
+| `create_doc_comment` | Create new comments |
+| `reply_to_comment` | Reply to existing comments |
+| `resolve_comment` | Resolve comments |
 
 ### 📊 Google Sheets ([`sheets_tools.py`](gsheets/sheets_tools.py))
 
@@ -300,6 +349,24 @@ When calling a tool:
 | `modify_sheet_values` | Write/update/clear cells |
 | `create_spreadsheet` | Create new spreadsheets |
 | `create_sheet` | Add sheets to existing files |
+| `read_sheet_comments` | Read all comments and replies |
+| `create_sheet_comment` | Create new comments |
+| `reply_to_sheet_comment` | Reply to existing comments |
+| `resolve_sheet_comment` | Resolve comments |
+
+### 🖼️ Google Slides ([`slides_tools.py`](gslides/slides_tools.py))
+
+| Tool | Description |
+|------|-------------|
+| `create_presentation` | Create new presentations |
+| `get_presentation` | Retrieve presentation details |
+| `batch_update_presentation` | Apply multiple updates at once |
+| `get_page` | Get specific slide information |
+| `get_page_thumbnail` | Generate slide thumbnails |
+| `read_presentation_comments` | Read all comments and replies |
+| `create_presentation_comment` | Create new comments |
+| `reply_to_presentation_comment` | Reply to existing comments |
+| `resolve_presentation_comment` | Resolve comments |
 
 ### 📝 Google Forms ([`forms_tools.py`](gforms/forms_tools.py))
 

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

@@ -1,19 +1,21 @@
 main.py,sha256=Mv5jfggqQ5XqzetKhccD2OmeWFnhidSbgzyKppCfywo,7078
 auth/__init__.py,sha256=gPCU3GE-SLy91S3D3CbX-XfKBm6hteK_VSPKx7yjT5s,42
-auth/google_auth.py,sha256=OdKFI7kW-R0peZutv9VXCnDvxH5jAtbeFYiXK9sxqjQ,25998
-auth/oauth_callback_server.py,sha256=-vaaLO9f7oz6QsHUXjRFHjlEleFm0Y9ccBB33YX22wQ,9177
+auth/google_auth.py,sha256=2UBbQgGcUPdUFWDbzdFy60NJLQ3SI45GIASzuzO1Tew,30717
+auth/oauth_callback_server.py,sha256=igrur3fkZSY0bawufrH4AN9fMNpobUdAUp1BG7AQC6w,9341
 auth/oauth_responses.py,sha256=qbirSB4d7mBRKcJKqGLrJxRAPaLHqObf9t-VMAq6UKA,7020
 auth/scopes.py,sha256=kMRdFN0wLyipFkp7IitTHs-M6zhZD-oieVd7fylueBc,3320
 auth/service_decorator.py,sha256=h9bkG1O6U-p4_yT1KseBKJvueprKd4SVJe1Bj2VrdXA,15669
 core/__init__.py,sha256=AHVKdPl6v4lUFm2R-KuGuAgEmCyfxseMeLGtntMcqCs,43
-core/server.py,sha256=WqAIIiH6X4ZsvgTiMc1NRsMNjUpfmXGdkMn-zbbyCds,9440
+core/comments.py,sha256=n-S84v5N5x3LbL45vGUerERhNPYvuSlugpOboYtPGgw,11328
+core/context.py,sha256=zNgPXf9EO2EMs9sQkfKiywoy6sEOksVNgOrJMA_c30Y,768
+core/server.py,sha256=8A5_o6RCZ3hhsAiCszZhHiUJbVVrxJLspcvCiMmt27Q,9265
 core/utils.py,sha256=2t5wbLtSLodxNKNAZb-jmR8Zg6mm-Rady-LpnXCP-1g,10297
 gcalendar/__init__.py,sha256=D5fSdAwbeomoaj7XAdxSnIy-NVKNkpExs67175bOtfc,46
 gcalendar/calendar_tools.py,sha256=SIiSJRxG3G9KsScow0pYwew600_PdtFqlOo-y2vXQRo,22144
 gchat/__init__.py,sha256=XBjH4SbtULfZHgFCxk3moel5XqG599HCgZWl_veIncg,88
 gchat/chat_tools.py,sha256=cIeXBBxWkFCdQNJ23BkX8IoDho6J8ZcfLsPjctUWyfA,7274
 gdocs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gdocs/docs_tools.py,sha256=dzzz3Hf5Pvhy2jKzCQi39d2YglcfUaSpJverjwFyjh4,8070
+gdocs/docs_tools.py,sha256=gWPBXf2M_ucP9LasAW0JAlCFAwixlcbAFDGS62xspZ4,8482
 gdrive/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gdrive/drive_tools.py,sha256=l-6IpHTstRMKIY2CU4DFTTNfEQ5rVbafgwo8BrbJ9Bk,15257
 gforms/__init__.py,sha256=pL91XixrEp9YjpM-AYwONIEfeCP2OumkEG0Io5V4boE,37
@@ -21,12 +23,12 @@ gforms/forms_tools.py,sha256=reJF3qw9WwW6-aCOkS2x5jVBvdRx4Za8onEZBC57RXk,9663
 gmail/__init__.py,sha256=l8PZ4_7Oet6ZE7tVu9oQ3-BaRAmI4YzAO86kf9uu6pU,60
 gmail/gmail_tools.py,sha256=UIcws__Akw0kxbasc9fYH7rkzDw_7L-LJU1LQU_p-sA,24754
 gsheets/__init__.py,sha256=jFfhD52w_EOVw6N5guf_dIc9eP2khW_eS9UAPJg_K3k,446
-gsheets/sheets_tools.py,sha256=ctUvaA-3I-iGwCCHOk9Bloh5P7XQDqxBnFAxFTqCTPc,11466
+gsheets/sheets_tools.py,sha256=TVlJ-jcIvJ_sJt8xO4-sBWIshb8rabJhjTmZfzHIJsU,11898
 gslides/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gslides/slides_tools.py,sha256=FyFbpUxfbaueyN4lbRk5WeoxK7NWbLDTBCiyDPtPFgM,9426
-workspace_mcp-1.0.2.dist-info/licenses/LICENSE,sha256=bB8L7rIyRy5o-WHxGgvRuY8hUTzNu4h3DTkvyV8XFJo,1070
-workspace_mcp-1.0.2.dist-info/METADATA,sha256=hQGlqB_KRitdIvjXm6nmvcu5EldsmlZ1UFyDoJcOEdc,15497
-workspace_mcp-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-workspace_mcp-1.0.2.dist-info/entry_points.txt,sha256=kPiEfOTuf-ptDM0Rf2OlyrFudGW7hCZGg4MCn2Foxs4,44
-workspace_mcp-1.0.2.dist-info/top_level.txt,sha256=Y8mAkTitLNE2zZEJ-DbqR9R7Cs1V1MMf-UploVdOvlw,73
-workspace_mcp-1.0.2.dist-info/RECORD,,
+gslides/slides_tools.py,sha256=wil3XRyUMzUbpBUMqis0CW5eRuwOrP0Lp7-6WbF4QVU,10117
+workspace_mcp-1.0.4.dist-info/licenses/LICENSE,sha256=bB8L7rIyRy5o-WHxGgvRuY8hUTzNu4h3DTkvyV8XFJo,1070
+workspace_mcp-1.0.4.dist-info/METADATA,sha256=PLCeesDmtActuNb-hVX3j0xA2wvLjHPWa9FFvjKNM_4,19406
+workspace_mcp-1.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+workspace_mcp-1.0.4.dist-info/entry_points.txt,sha256=kPiEfOTuf-ptDM0Rf2OlyrFudGW7hCZGg4MCn2Foxs4,44
+workspace_mcp-1.0.4.dist-info/top_level.txt,sha256=Y8mAkTitLNE2zZEJ-DbqR9R7Cs1V1MMf-UploVdOvlw,73
+workspace_mcp-1.0.4.dist-info/RECORD,,