added basic workplace tools

Author: ayomaska18

.env.example

@@ -1 +1,4 @@
 MCP_SERVER_URL=http://localhost:8081
+
+GOOGLE_OAUTH_CLIENT_ID=your-client-id.apps.googleusercontent.com
+GOOGLE_OAUTH_CLIENT_SECRET=GOCSPX-your-client-secret

pyproject.toml

@@ -14,6 +14,9 @@ dependencies = [
     "tavily-python>=0.7.13",
     "markitdown[all]>=0.1.4",
     "black>=25.12.0",
+    "google-api-python-client>=2.168.0",
+    "google-auth-httplib2>=0.2.0",
+    "google-auth-oauthlib>=1.2.2",
 ]
 
 [dependency-groups]

src/server.py

@@ -69,6 +69,27 @@ def _register_toolset(name: str, loader: Callable[[FastMCP], None]) -> None:
 except ImportError as e:
     logger.warning("PDF to Markdown tools module missing: %s", e)
 
+try:
+    from src.tools.google import gmail
+    
+    _register_toolset("gmail", gmail.register_tools)
+except ImportError as e:
+    logger.warning("Gmail tools module missing: %s", e)
+
+try:
+    from src.tools.google import calendar
+
+    _register_toolset("calendar", calendar.register_tools)
+except ImportError as e:
+    logger.warning("Google Calendar tools module missing: %s", e)
+
+try:
+    from src.tools.google import drive
+
+    _register_toolset("drive", drive.register_tools)
+except ImportError as e:
+    logger.warning("Google Drive tools module missing: %s", e)
+
 
 tool_count = len(getattr(getattr(mcp, "_tool_manager", None), "tools", []))
 logger.info("MCP server initialized with %d tools", tool_count)

src/tools/google/__init__.py

@@ -0,0 +1 @@
+# Google Workspace Tools

src/tools/google/auth.py

@@ -0,0 +1,167 @@
+import json
+import logging
+import os
+from pathlib import Path
+
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import build
+
+logger = logging.getLogger("humcp.google.auth")
+
+TOKEN_PATH = Path.home() / ".humcp" / "google_token.json"
+CLIENT_SECRET_PATH = Path.home() / ".humcp" / "client_secret.json"
+
+SCOPES = {
+    "gmail_readonly": "https://www.googleapis.com/auth/gmail.readonly",
+    "gmail_send": "https://www.googleapis.com/auth/gmail.send",
+    "gmail_modify": "https://www.googleapis.com/auth/gmail.modify",
+    "calendar": "https://www.googleapis.com/auth/calendar",
+    "calendar_readonly": "https://www.googleapis.com/auth/calendar.readonly",
+    "drive": "https://www.googleapis.com/auth/drive",
+    "drive_readonly": "https://www.googleapis.com/auth/drive.readonly",
+    "drive_file": "https://www.googleapis.com/auth/drive.file",
+}
+
+def _ensure_config_dir() -> None:
+    """Ensure the config directory exists."""
+    TOKEN_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+
+def load_client_config() -> dict | None:
+    """Load OAuth client configuration from environment or file."""
+    client_id = os.getenv("GOOGLE_OAUTH_CLIENT_ID")
+    client_secret = os.getenv("GOOGLE_OAUTH_CLIENT_SECRET")
+
+    if client_id and client_secret:
+        logger.debug("Using OAuth credentials from environment variables")
+        return {
+            "installed": {
+                "client_id": client_id,
+                "client_secret": client_secret,
+                "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+                "token_uri": "https://oauth2.googleapis.com/token",
+                "redirect_uris": ["http://localhost"],
+            }
+        }
+
+    if CLIENT_SECRET_PATH.exists():
+        logger.debug("Using OAuth credentials from %s", CLIENT_SECRET_PATH)
+        with open(CLIENT_SECRET_PATH) as f:
+            return json.load(f)
+
+    return None
+
+
+def get_credentials(scopes: list[str]) -> Credentials | None:
+    """Get valid credentials, refreshing or re-authenticating as needed."""
+    _ensure_config_dir()
+    creds = None
+
+    # Load existing token if available
+    if TOKEN_PATH.exists():
+        try:
+            creds = Credentials.from_authorized_user_file(str(TOKEN_PATH), scopes)
+            logger.debug("Loaded existing credentials from token file")
+        except Exception as e:
+            logger.warning("Failed to load existing token: %s", e)
+            creds = None
+
+    # Refresh or get new credentials
+    if creds and creds.expired and creds.refresh_token:
+        try:
+            logger.info("Refreshing expired credentials")
+            creds.refresh(Request())
+            _save_credentials(creds)
+        except Exception as e:
+            logger.warning("Failed to refresh token: %s", e)
+            creds = None
+
+    if not creds or not creds.valid:
+        creds = _run_auth_flow(scopes)
+
+    return creds
+
+
+def _run_auth_flow(scopes: list[str]) -> Credentials | None:
+    """Run the OAuth authorization flow."""
+    client_config = load_client_config()
+    if not client_config:
+        logger.error(
+            "Google OAuth not configured. Set GOOGLE_OAUTH_CLIENT_ID and "
+            "GOOGLE_OAUTH_CLIENT_SECRET environment variables, or create "
+            "%s",
+            CLIENT_SECRET_PATH,
+        )
+        return None
+
+    try:
+        # Allow http for localhost during development
+        os.environ["OAUTHLIB_INSECURE_TRANSPORT"] = "1"
+
+        flow = InstalledAppFlow.from_client_config(client_config, scopes)
+        logger.info("Opening browser for Google authentication...")
+        creds = flow.run_local_server(port=0)
+
+        _save_credentials(creds)
+        logger.info("Authentication successful")
+        return creds
+
+    except Exception as e:
+        logger.error("OAuth flow failed: %s", e)
+        return None
+
+
+def _save_credentials(creds: Credentials) -> None:
+    """Save credentials to token file."""
+    _ensure_config_dir()
+    with open(TOKEN_PATH, "w") as f:
+        f.write(creds.to_json())
+    logger.debug("Credentials saved to %s", TOKEN_PATH)
+
+
+def get_google_service(service_name: str, version: str, scopes: list[str]):
+    """Build an authenticated Google API service client."""
+    creds = get_credentials(scopes)
+    if not creds:
+        raise ValueError(
+            "Google authentication failed. Please configure OAuth credentials:\n"
+            "1. Set GOOGLE_OAUTH_CLIENT_ID and GOOGLE_OAUTH_CLIENT_SECRET env vars\n"
+            "2. Or create ~/.humcp/client_secret.json with OAuth credentials"
+        )
+
+    return build(service_name, version, credentials=creds)
+
+
+def check_auth_status() -> dict:
+    """Check current authentication status."""
+    config = load_client_config()
+    has_config = config is not None
+    has_token = TOKEN_PATH.exists()
+
+    status = {
+        "configured": has_config,
+        "authenticated": False,
+        "token_path": str(TOKEN_PATH),
+        "config_source": None,
+    }
+
+    if has_config:
+        if os.getenv("GOOGLE_OAUTH_CLIENT_ID"):
+            status["config_source"] = "environment"
+        else:
+            status["config_source"] = str(CLIENT_SECRET_PATH)
+
+    if has_token:
+        try:
+            creds = Credentials.from_authorized_user_file(str(TOKEN_PATH))
+            status["authenticated"] = creds.valid or creds.refresh_token is not None
+            if creds.expired:
+                status["token_status"] = "expired (will refresh)"
+            elif creds.valid:
+                status["token_status"] = "valid"
+        except Exception:
+            status["token_status"] = "invalid"
+
+    return status

src/tools/google/calendar.py

@@ -0,0 +1,185 @@
+import asyncio
+import logging
+from datetime import datetime, timedelta, timezone
+
+from fastmcp import FastMCP
+
+from src.tools.google.auth import SCOPES, get_google_service
+
+logger = logging.getLogger("humcp.tools.google.calendar")
+
+# Scopes required for Calendar operations
+CALENDAR_READONLY_SCOPES = [SCOPES["calendar_readonly"]]
+CALENDAR_FULL_SCOPES = [SCOPES["calendar"]]
+
+
+async def list_calendars() -> dict:
+    """List all calendars accessible to the user."""
+    try:
+
+        def _list():
+            service = get_google_service("calendar", "v3", CALENDAR_READONLY_SCOPES)
+            results = service.calendarList().list().execute()
+            calendars = results.get("items", [])
+            return {
+                "calendars": [
+                    {
+                        "id": cal["id"],
+                        "name": cal.get("summary", ""),
+                        "description": cal.get("description", ""),
+                        "primary": cal.get("primary", False),
+                        "access_role": cal.get("accessRole", ""),
+                    }
+                    for cal in calendars
+                ],
+                "total": len(calendars),
+            }
+
+        logger.info("calendar_list")
+        result = await asyncio.to_thread(_list)
+        return {"success": True, "data": result}
+    except Exception as e:
+        logger.exception("calendar_list failed")
+        return {"success": False, "error": str(e)}
+
+
+async def events(
+    calendar_id: str = "primary",
+    days_ahead: int = 7,
+    max_results: int = 50,
+) -> dict:
+    """List upcoming events from a calendar."""
+    try:
+
+        def _list_events():
+            service = get_google_service("calendar", "v3", CALENDAR_READONLY_SCOPES)
+
+            now = datetime.now(timezone.utc)
+            time_min = now.isoformat()
+            time_max = (now + timedelta(days=days_ahead)).isoformat()
+
+            results = (
+                service.events()
+                .list(
+                    calendarId=calendar_id,
+                    timeMin=time_min,
+                    timeMax=time_max,
+                    maxResults=max_results,
+                    singleEvents=True,
+                    orderBy="startTime",
+                )
+                .execute()
+            )
+
+            items = results.get("items", [])
+            return {
+                "events": [
+                    {
+                        "id": event["id"],
+                        "title": event.get("summary", "(no title)"),
+                        "description": event.get("description", ""),
+                        "start": event.get("start", {}).get(
+                            "dateTime", event.get("start", {}).get("date", "")
+                        ),
+                        "end": event.get("end", {}).get(
+                            "dateTime", event.get("end", {}).get("date", "")
+                        ),
+                        "location": event.get("location", ""),
+                        "status": event.get("status", ""),
+                        "html_link": event.get("htmlLink", ""),
+                    }
+                    for event in items
+                ],
+                "total": len(items),
+            }
+
+        logger.info(
+            "calendar_events calendar_id=%s days_ahead=%s", calendar_id, days_ahead
+        )
+        result = await asyncio.to_thread(_list_events)
+        return {"success": True, "data": result}
+    except Exception as e:
+        logger.exception("calendar_events failed")
+        return {"success": False, "error": str(e)}
+
+
+async def create_event(
+    title: str,
+    start_time: str,
+    end_time: str,
+    calendar_id: str = "primary",
+    description: str = "",
+    location: str = "",
+    attendees: str = "",
+) -> dict:
+    """Create a new calendar event."""
+    try:
+
+        def _create():
+            service = get_google_service("calendar", "v3", CALENDAR_FULL_SCOPES)
+
+            event_body = {
+                "summary": title,
+                "description": description,
+                "location": location,
+                "start": {"dateTime": start_time, "timeZone": "UTC"},
+                "end": {"dateTime": end_time, "timeZone": "UTC"},
+            }
+
+            if attendees:
+                event_body["attendees"] = [
+                    {"email": email.strip()} for email in attendees.split(",")
+                ]
+
+            event = (
+                service.events()
+                .insert(calendarId=calendar_id, body=event_body)
+                .execute()
+            )
+
+            return {
+                "id": event["id"],
+                "title": event.get("summary"),
+                "start": event.get("start", {}).get("dateTime"),
+                "end": event.get("end", {}).get("dateTime"),
+                "html_link": event.get("htmlLink"),
+            }
+
+        logger.info("calendar_create_event title=%s", title)
+        result = await asyncio.to_thread(_create)
+        return {"success": True, "data": result}
+    except Exception as e:
+        logger.exception("calendar_create_event failed")
+        return {"success": False, "error": str(e)}
+
+
+async def delete_event(
+    event_id: str,
+    calendar_id: str = "primary",
+) -> dict:
+    """Delete a calendar event."""
+    try:
+
+        def _delete():
+            service = get_google_service("calendar", "v3", CALENDAR_FULL_SCOPES)
+            service.events().delete(
+                calendarId=calendar_id, eventId=event_id
+            ).execute()
+            return {"deleted_event_id": event_id}
+
+        logger.info("calendar_delete_event event_id=%s", event_id)
+        result = await asyncio.to_thread(_delete)
+        return {"success": True, "data": result}
+    except Exception as e:
+        logger.exception("calendar_delete_event failed")
+        return {"success": False, "error": str(e)}
+
+
+def register_tools(mcp: FastMCP) -> None:
+    """Register all Google Calendar tools with the MCP server."""
+    logger.info("Registering Google Calendar tools")
+
+    mcp.tool(name="calendar_list")(list_calendars)
+    mcp.tool(name="calendar_events")(events)
+    mcp.tool(name="calendar_create_event")(create_event)
+    mcp.tool(name="calendar_delete_event")(delete_event)