@alanse/mcp-server-google-workspace 1.0.0 → 1.0.2

package/README.md

@@ -1,9 +1,9 @@
 # MCP Server - Google Workspace
 
-**The most comprehensive MCP server for Google Workspace** - Complete programmatic control over Sheets, Docs, Drive, and future Calendar, Forms integration.
+**The most comprehensive MCP server for Google Workspace** - Complete programmatic control over Sheets, Docs, Drive, Gmail, Calendar, and future Forms integration.
 
-🚀 **Current Status**: 82 tools (Drive: 2, Sheets: 57, Docs: 23)
-📅 **Roadmap**: Calendar, Forms, Gmail, Slides
+🚀 **Current Status**: 130 tools (Drive: 21, Sheets: 57, Docs: 23, Gmail: 11, Calendar: 18)
+📅 **Roadmap**: Forms, Slides
 
 Extended implementation by Alanse inc.
 
@@ -13,12 +13,103 @@ Extended implementation by Alanse inc.
 
 ### 📊 Extended Google Workspace API Implementation
 
-**82 Total Tools** = 2 GDrive + **57 Google Sheets** + **23 Google Docs** operations
+**130 Total Tools** = **21 Google Drive** + **57 Google Sheets** + **23 Google Docs** + **11 Gmail** + **18 Calendar** operations
 
 #### Tool Categories
 
-**Google Drive Operations (2 tools)**
-- Search & File Management
+**Google Drive Operations (21 tools)**
+
+#### Basic Operations (4 tools)
+
+- Search Files (Advanced Query Support)
+- Read File Contents
+- List Files (Filter, Pagination, Sorting)
+- Get File Metadata
+
+#### File Operations (7 tools)
+
+- Upload File
+- Create File
+- Delete File (Move to Trash)
+- Copy File
+- Move File
+- Rename File
+- Update File Content
+
+#### Folder Management (3 tools)
+
+- Create Folder
+- List Folder Contents
+- Move File to Folder
+
+#### Permissions Management (4 tools)
+
+- Share File (User/Group/Domain/Anyone)
+- List File Permissions
+- Update Permission Role
+- Remove Permission
+
+#### Advanced Operations (3 tools)
+
+- Export File (Google Workspace Docs to PDF/DOCX/etc)
+- List File Revisions
+- Empty Trash
+
+**Gmail Operations (11 tools)**
+
+#### Basic Operations (4 tools)
+
+- List Labels, Search Messages, Get Message, Get Thread
+
+#### Label Management (2 tools)
+
+- Modify Labels (Add/Remove), Manage Labels (Create/Update/Delete)
+
+#### Send Operations (2 tools)
+
+- Send Message (Plain/HTML with CC/BCC), Draft Message
+
+#### Batch Operations (3 tools)
+
+- Get Messages Batch, Get Threads Batch, Batch Modify Labels
+
+**Google Calendar Operations (18 tools)**
+
+#### Basic Event Operations (5 tools)
+
+- List Events (Time range, search, pagination)
+- Get Event (Full event details)
+- Create Event (Title, time, location, attendees, Google Meet)
+- Update Event (Modify any event properties)
+- Delete Event (Remove with notifications)
+
+#### Advanced Event Operations (3 tools)
+
+- Quick Add Event (Natural language: "Meeting tomorrow at 2pm")
+- List Event Instances (Recurring event occurrences)
+- Move Event (Transfer between calendars)
+
+#### Calendar List Operations (2 tools)
+
+- List Calendars (User's calendar list with access roles)
+- Get Calendar from List (Detailed calendar information)
+
+#### Calendar Management (3 tools)
+
+- Create Calendar (New secondary calendar)
+- Get Calendar Metadata (Calendar details and settings)
+- Update Calendar (Modify title, description, timezone)
+
+#### Access Control (2 tools)
+
+- List ACL Rules (View sharing settings)
+- Add ACL Rule (Share calendar with users/groups/domains)
+
+#### Utility Operations (3 tools)
+
+- Get Color Palette (Available calendar/event colors)
+- Query Free/Busy (Check availability across calendars)
+- List Settings (User's Calendar preferences)
 
 **Google Docs Operations (23 tools)**
 
@@ -91,8 +182,11 @@ The server provides access to Google Drive files:
 1. [Create a new Google Cloud project](https://console.cloud.google.com/projectcreate)
 2. [Enable the Google Drive API](https://console.cloud.google.com/workspace-api/products)
 3. [Configure an OAuth consent screen](https://console.cloud.google.com/apis/credentials/consent) ("internal" is fine for testing)
-4. Add OAuth scopes `https://www.googleapis.com/auth/drive.readonly`, `https://www.googleapis.com/auth/spreadsheets`
-5. In order to allow interaction with sheets and docs you will also need to enable the [Google Sheets API](https://console.cloud.google.com/apis/api/sheets.googleapis.com/) and [Google Docs API](https://console.cloud.google.com/marketplace/product/google/docs.googleapis.com) in your workspaces Enabled API and Services section.
+4. Add OAuth scopes:
+   - `https://www.googleapis.com/auth/drive` (for Drive file operations - read & write)
+   - `https://www.googleapis.com/auth/spreadsheets` (for Sheets operations)
+   - `https://www.googleapis.com/auth/gmail.modify` (for Gmail operations)
+5. In order to allow interaction with sheets and docs you will also need to enable the [Google Sheets API](https://console.cloud.google.com/apis/api/sheets.googleapis.com/), [Google Docs API](https://console.cloud.google.com/marketplace/product/google/docs.googleapis.com), and [Gmail API](https://console.cloud.google.com/apis/api/gmail.googleapis.com) in your workspaces Enabled API and Services section.
 6. [Create an OAuth Client ID](https://console.cloud.google.com/apis/credentials/oauthclient) for application type "Desktop App"
 7. Download the JSON file of your client's OAuth keys
 8. Rename the key file to `gcp-oauth.keys.json` and place into the path you specify with `GWORKSPACE_CREDS_DIR` (i.e. `/Users/username/.config/mcp-google-workspace`)
@@ -152,27 +246,28 @@ Replace `<YOUR_CLIENT_ID>`, `<YOUR_CLIENT_SECRET>`, and `/path/to/config/directo
 
 ## 📈 Project Status
 
-✅ **Phase 1-12 Complete** (2026-01-06)
-- **59 Tools Implemented** (57 Sheets + 2 GDrive)
-- **155 Tests** (100% Pass Rate)
+✅ **Complete** (2026-01-06)
+
+- **112 Tools Implemented** (21 Drive + 57 Sheets + 23 Docs + 11 Gmail)
+- **268+ Tests** (100% Pass Rate)
 - **Production Ready**
 
 ## 🗺️ Roadmap
 
-### Current: Google Sheets & Drive ✅
+### Completed ✅
 
-- ✅ **Google Drive**: 2 tools (Search, Read)
+- ✅ **Google Drive**: 21 tools (File operations, folder management, permissions, advanced features)
 - ✅ **Google Sheets**: 57 tools (Complete API coverage)
+- ✅ **Google Docs**: 23 tools (Document creation, editing, formatting, elements)
+- ✅ **Gmail**: 11 tools (Labels, search, send, batch operations)
 
 ### Coming Soon
 
-- 📝 **Google Docs**: Document creation, editing, formatting (~15-20 tools)
 - 📅 **Google Calendar**: Event management, scheduling (~10-15 tools)
 - 📋 **Google Forms**: Form creation, response management (~10-15 tools)
-- 📧 **Gmail**: Email operations, thread management (~10-15 tools)
 - 🎬 **Google Slides**: Presentation creation, editing (~15-20 tools)
 
-**Goal**: 100+ tools covering the entire Google Workspace ecosystem
+**Goal**: 150+ tools covering the entire Google Workspace ecosystem
 
 ## 🛠️ Development
 
@@ -204,7 +299,7 @@ npm run watch
 
 ### Testing
 
-The project uses [Vitest](https://vitest.dev/) for testing:
+The project uses [Vitest](https://vitest.dev/) for unit testing:
 
 ```bash
 # Run all tests
@@ -220,6 +315,40 @@ npm run test:ui
 npm run test:coverage
 ```
 
+### Interactive Testing with MCP Inspector
+
+[MCP Inspector](https://modelcontextprotocol.io/docs/tools/inspector) is the official debugging tool for MCP servers. It provides an interactive interface to test all 130 tools in real-time.
+
+**Launch Inspector:**
+
+```bash
+npm run inspect
+```
+
+This opens a browser interface where you can:
+
+- 🔍 **Browse all 130 tools** - View complete tool schemas and descriptions
+- ⚡ **Test tools interactively** - Execute any tool with custom parameters
+- 📊 **Monitor responses** - See real-time responses and error messages
+- 🐛 **Debug issues** - View server logs and notifications
+- 🧪 **Test edge cases** - Try invalid inputs and concurrent operations
+
+**Example workflow:**
+
+1. Start the inspector: `npm run inspect`
+2. Navigate to the **Tools** tab
+3. Select a tool (e.g., `calendar_create_event`)
+4. Fill in the parameters (summary, startTime, endTime)
+5. Click **Execute** to test the tool
+6. View the response and verify the behavior
+
+**Recommended for:**
+
+- Testing new Calendar API tools
+- Verifying OAuth authentication flow
+- Debugging API errors and edge cases
+- Exploring available tools before integration
+
 ### Release Process
 
 This project uses [release-please](https://github.com/googleapis/release-please) for automated releases.

package/dist/auth.js

@@ -6,6 +6,11 @@ export const SCOPES = [
     "https://www.googleapis.com/auth/drive.readonly",
     "https://www.googleapis.com/auth/spreadsheets",
     "https://www.googleapis.com/auth/documents",
+    "https://www.googleapis.com/auth/gmail.readonly",
+    "https://www.googleapis.com/auth/gmail.send",
+    "https://www.googleapis.com/auth/gmail.modify",
+    "https://www.googleapis.com/auth/gmail.labels",
+    "https://www.googleapis.com/auth/calendar",
 ];
 // Get credentials directory from environment variable or use default
 const CREDS_DIR = process.env.GWORKSPACE_CREDS_DIR ||

package/dist/lib/calendar-helpers.js

@@ -0,0 +1,197 @@
+/**
+ * Google Calendar Helper Functions
+ *
+ * Utilities for Google Calendar API operations including:
+ * - Event formatting and display
+ * - Date/time parsing and formatting
+ * - Calendar URL generation
+ * - Free/busy data formatting
+ * - Attendee and recurrence handling
+ */
+/**
+ * Format a single calendar event for display
+ */
+export function formatEvent(event, calendarId = "primary") {
+    const lines = [];
+    // Event ID and status
+    lines.push(`Event ID: ${event.id}`);
+    if (event.status) {
+        lines.push(`Status: ${event.status}`);
+    }
+    // Summary (title)
+    if (event.summary) {
+        lines.push(`Title: ${event.summary}`);
+    }
+    // Date and time
+    const { startFormatted, endFormatted } = formatDateTime(event);
+    lines.push(`Start: ${startFormatted}`);
+    lines.push(`End: ${endFormatted}`);
+    // Location
+    if (event.location) {
+        lines.push(`Location: ${event.location}`);
+    }
+    // Description
+    if (event.description) {
+        const desc = event.description.length > 200
+            ? event.description.substring(0, 200) + "..."
+            : event.description;
+        lines.push(`Description: ${desc}`);
+    }
+    // Attendees
+    if (event.attendees && event.attendees.length > 0) {
+        lines.push(`Attendees (${event.attendees.length}):`);
+        event.attendees.forEach((attendee) => {
+            const status = attendee.responseStatus || "needsAction";
+            const organizer = attendee.organizer ? " (organizer)" : "";
+            lines.push(`  - ${attendee.email} [${status}]${organizer}`);
+        });
+    }
+    // Recurrence
+    if (event.recurrence && event.recurrence.length > 0) {
+        lines.push(`Recurrence: ${event.recurrence.join(", ")}`);
+    }
+    // Web link
+    if (event.htmlLink) {
+        lines.push(`Link: ${event.htmlLink}`);
+    }
+    // Conference data (Google Meet, Zoom, etc.)
+    if (event.conferenceData?.entryPoints) {
+        const meetLink = event.conferenceData.entryPoints.find((ep) => ep.entryPointType === "video");
+        if (meetLink?.uri) {
+            lines.push(`Meeting Link: ${meetLink.uri}`);
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Format a list of calendar events
+ */
+export function formatEventList(events, calendarId = "primary") {
+    if (!events || events.length === 0) {
+        return "No events found.";
+    }
+    const lines = [];
+    lines.push(`Found ${events.length} event(s):\n`);
+    events.forEach((event, index) => {
+        lines.push(`[${index + 1}] ${event.summary || "(No title)"}`);
+        const { startFormatted } = formatDateTime(event);
+        lines.push(`    Time: ${startFormatted}`);
+        if (event.location) {
+            lines.push(`    Location: ${event.location}`);
+        }
+        if (event.attendees) {
+            lines.push(`    Attendees: ${event.attendees.length}`);
+        }
+        lines.push(`    ID: ${event.id}`);
+        lines.push("");
+    });
+    return lines.join("\n");
+}
+/**
+ * Format event date/time for display
+ */
+export function formatDateTime(event) {
+    let startFormatted = "Unknown";
+    let endFormatted = "Unknown";
+    let isAllDay = false;
+    // Check if all-day event
+    if (event.start?.date) {
+        startFormatted = event.start.date;
+        endFormatted = event.end?.date || event.start.date;
+        isAllDay = true;
+    }
+    else if (event.start?.dateTime) {
+        const startDate = new Date(event.start.dateTime);
+        const endDate = event.end?.dateTime ? new Date(event.end.dateTime) : startDate;
+        const options = {
+            year: "numeric",
+            month: "short",
+            day: "numeric",
+            hour: "2-digit",
+            minute: "2-digit",
+            timeZoneName: "short",
+        };
+        startFormatted = startDate.toLocaleString("en-US", options);
+        endFormatted = endDate.toLocaleString("en-US", options);
+    }
+    return { startFormatted, endFormatted, isAllDay };
+}
+/**
+ * Generate Google Calendar web URL for an event
+ */
+export function generateCalendarWebUrl(eventId, calendarId = "primary") {
+    const encodedCalendarId = encodeURIComponent(calendarId);
+    const encodedEventId = encodeURIComponent(eventId);
+    return `https://calendar.google.com/calendar/u/0/r/eventedit/${encodedEventId}?calendarId=${encodedCalendarId}`;
+}
+/**
+ * Format free/busy query response
+ */
+export function formatFreeBusyResponse(response) {
+    const lines = [];
+    if (!response.calendars) {
+        return "No calendar data available.";
+    }
+    Object.entries(response.calendars).forEach(([calendarId, calendarData]) => {
+        lines.push(`\nCalendar: ${calendarId}`);
+        if (calendarData.errors && calendarData.errors.length > 0) {
+            lines.push("  Errors:");
+            calendarData.errors.forEach((error) => {
+                lines.push(`    - ${error.reason}: ${error.domain}`);
+            });
+        }
+        if (calendarData.busy && calendarData.busy.length > 0) {
+            lines.push(`  Busy periods (${calendarData.busy.length}):`);
+            calendarData.busy.forEach((period, index) => {
+                const start = period.start ? new Date(period.start).toLocaleString() : "Unknown";
+                const end = period.end ? new Date(period.end).toLocaleString() : "Unknown";
+                lines.push(`    ${index + 1}. ${start} - ${end}`);
+            });
+        }
+        else {
+            lines.push("  No busy periods - calendar is free!");
+        }
+    });
+    return lines.join("\n");
+}
+/**
+ * Parse ISO 8601 datetime or date string to appropriate format for Calendar API
+ */
+export function parseDateTime(dateTimeStr) {
+    // Check if it's a date-only string (YYYY-MM-DD)
+    if (/^\d{4}-\d{2}-\d{2}$/.test(dateTimeStr)) {
+        return { date: dateTimeStr };
+    }
+    // Otherwise, treat as datetime
+    return { dateTime: dateTimeStr };
+}
+/**
+ * Format attendee list for API request
+ */
+export function formatAttendees(emails) {
+    return emails.map((email) => ({
+        email: email.trim(),
+    }));
+}
+/**
+ * Validate event time range
+ */
+export function validateTimeRange(startTime, endTime) {
+    try {
+        const start = new Date(startTime);
+        const end = new Date(endTime);
+        if (isNaN(start.getTime())) {
+            return { valid: false, error: "Invalid start time format" };
+        }
+        if (isNaN(end.getTime())) {
+            return { valid: false, error: "Invalid end time format" };
+        }
+        if (end <= start) {
+            return { valid: false, error: "End time must be after start time" };
+        }
+        return { valid: true };
+    }
+    catch (error) {
+        return { valid: false, error: "Error parsing time range" };
+    }
+}

package/dist/lib/drive-helpers.js

@@ -0,0 +1,263 @@
+/**
+ * Google Drive Helper Functions
+ *
+ * Utilities for Google Drive API operations including:
+ * - File metadata formatting
+ * - Permission formatting
+ * - MIME type conversion
+ * - URL generation
+ * - File upload handling
+ */
+/**
+ * Format file metadata for display
+ */
+export function formatFileMetadata(file, detailed = false) {
+    const id = file.id || "";
+    const name = file.name || "Unnamed";
+    const mimeType = file.mimeType || "unknown";
+    const size = file.size ? formatFileSize(parseInt(file.size)) : "N/A";
+    const modifiedTime = file.modifiedTime
+        ? new Date(file.modifiedTime).toLocaleString()
+        : "Unknown";
+    const webViewLink = file.webViewLink || "";
+    if (!detailed) {
+        return `${name} (${id}) - ${mimeType}`;
+    }
+    let output = `📄 ${name}\n`;
+    output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+    output += `ID: ${id}\n`;
+    output += `MIME Type: ${mimeType}\n`;
+    output += `Size: ${size}\n`;
+    output += `Modified: ${modifiedTime}\n`;
+    if (webViewLink) {
+        output += `Web Link: ${webViewLink}\n`;
+    }
+    if (file.parents && file.parents.length > 0) {
+        output += `Parent Folder(s): ${file.parents.join(", ")}\n`;
+    }
+    output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+    return output;
+}
+/**
+ * Format file list for display
+ */
+export function formatFileList(files, nextPageToken) {
+    if (files.length === 0) {
+        return "No files found.";
+    }
+    let output = `Found ${files.length} file(s):\n\n`;
+    files.forEach((file, index) => {
+        const name = file.name || "Unnamed";
+        const id = file.id || "";
+        const mimeType = file.mimeType || "unknown";
+        const size = file.size ? formatFileSize(parseInt(file.size)) : "N/A";
+        output += `${index + 1}. ${name}\n`;
+        output += `   ID: ${id}\n`;
+        output += `   Type: ${mimeType}\n`;
+        output += `   Size: ${size}\n`;
+        if (file.webViewLink) {
+            output += `   Link: ${file.webViewLink}\n`;
+        }
+        output += `\n`;
+    });
+    if (nextPageToken) {
+        output += `\nMore results available. Use pageToken: ${nextPageToken}`;
+    }
+    return output;
+}
+/**
+ * Format permission for display
+ */
+export function formatPermission(permission) {
+    const role = permission.role || "unknown";
+    const type = permission.type || "unknown";
+    const emailAddress = permission.emailAddress || "";
+    const displayName = permission.displayName || "";
+    const id = permission.id || "";
+    let output = `Permission ID: ${id}\n`;
+    output += `  Role: ${role}\n`;
+    output += `  Type: ${type}\n`;
+    if (emailAddress) {
+        output += `  Email: ${emailAddress}\n`;
+    }
+    if (displayName) {
+        output += `  Name: ${displayName}\n`;
+    }
+    return output;
+}
+/**
+ * Format permission list for display
+ */
+export function formatPermissionList(permissions) {
+    if (permissions.length === 0) {
+        return "No permissions found.";
+    }
+    let output = `Total permissions: ${permissions.length}\n\n`;
+    permissions.forEach((permission, index) => {
+        output += `${index + 1}. ${formatPermission(permission)}\n`;
+    });
+    return output;
+}
+/**
+ * Format revision for display
+ */
+export function formatRevision(revision) {
+    const id = revision.id || "";
+    const modifiedTime = revision.modifiedTime
+        ? new Date(revision.modifiedTime).toLocaleString()
+        : "Unknown";
+    const lastModifyingUser = revision.lastModifyingUser?.displayName || "Unknown";
+    const size = revision.size ? formatFileSize(parseInt(revision.size)) : "N/A";
+    let output = `Revision ID: ${id}\n`;
+    output += `  Modified: ${modifiedTime}\n`;
+    output += `  Modified by: ${lastModifyingUser}\n`;
+    output += `  Size: ${size}\n`;
+    return output;
+}
+/**
+ * Format revision list for display
+ */
+export function formatRevisionList(revisions) {
+    if (revisions.length === 0) {
+        return "No revisions found.";
+    }
+    let output = `Total revisions: ${revisions.length}\n\n`;
+    revisions.forEach((revision, index) => {
+        output += `${index + 1}. ${formatRevision(revision)}\n`;
+    });
+    return output;
+}
+/**
+ * Convert MIME type for export
+ */
+export function convertMimeType(sourceMimeType, targetFormat) {
+    // Google Workspace document types
+    const googleMimeTypes = {
+        "application/vnd.google-apps.document": {
+            pdf: "application/pdf",
+            docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+            html: "text/html",
+            txt: "text/plain",
+            odt: "application/vnd.oasis.opendocument.text",
+            rtf: "application/rtf",
+            epub: "application/epub+zip",
+            markdown: "text/markdown",
+        },
+        "application/vnd.google-apps.spreadsheet": {
+            pdf: "application/pdf",
+            xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            csv: "text/csv",
+            ods: "application/vnd.oasis.opendocument.spreadsheet",
+            tsv: "text/tab-separated-values",
+            html: "text/html",
+        },
+        "application/vnd.google-apps.presentation": {
+            pdf: "application/pdf",
+            pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+            odp: "application/vnd.oasis.opendocument.presentation",
+            txt: "text/plain",
+        },
+        "application/vnd.google-apps.drawing": {
+            pdf: "application/pdf",
+            png: "image/png",
+            jpeg: "image/jpeg",
+            svg: "image/svg+xml",
+        },
+    };
+    if (!targetFormat) {
+        // Default export formats
+        const defaults = {
+            "application/vnd.google-apps.document": "application/pdf",
+            "application/vnd.google-apps.spreadsheet": "text/csv",
+            "application/vnd.google-apps.presentation": "application/pdf",
+            "application/vnd.google-apps.drawing": "image/png",
+        };
+        return defaults[sourceMimeType] || "application/pdf";
+    }
+    const formats = googleMimeTypes[sourceMimeType];
+    if (!formats) {
+        throw new Error(`Unsupported source MIME type: ${sourceMimeType}`);
+    }
+    const targetMimeType = formats[targetFormat.toLowerCase()];
+    if (!targetMimeType) {
+        throw new Error(`Unsupported export format '${targetFormat}' for MIME type '${sourceMimeType}'`);
+    }
+    return targetMimeType;
+}
+/**
+ * Generate Google Drive web URL for a file or folder
+ */
+export function generateDriveWebUrl(fileId) {
+    return `https://drive.google.com/file/d/${fileId}/view`;
+}
+/**
+ * Generate folder web URL
+ */
+export function generateFolderWebUrl(folderId) {
+    return `https://drive.google.com/drive/folders/${folderId}`;
+}
+/**
+ * Format file size to human-readable format
+ */
+function formatFileSize(bytes) {
+    if (bytes === 0)
+        return "0 Bytes";
+    const k = 1024;
+    const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + " " + sizes[i];
+}
+/**
+ * Get MIME type for folder
+ */
+export const FOLDER_MIME_TYPE = "application/vnd.google-apps.folder";
+/**
+ * Check if MIME type is a Google Workspace document
+ */
+export function isGoogleWorkspaceDocument(mimeType) {
+    return mimeType.startsWith("application/vnd.google-apps.");
+}
+/**
+ * Get icon for MIME type
+ */
+export function getFileIcon(mimeType) {
+    const icons = {
+        "application/vnd.google-apps.folder": "📁",
+        "application/vnd.google-apps.document": "📝",
+        "application/vnd.google-apps.spreadsheet": "📊",
+        "application/vnd.google-apps.presentation": "📊",
+        "application/vnd.google-apps.drawing": "🎨",
+        "application/pdf": "📄",
+        "image/png": "🖼️",
+        "image/jpeg": "🖼️",
+        "text/plain": "📃",
+        "application/zip": "🗜️",
+    };
+    return icons[mimeType] || "📄";
+}
+/**
+ * Format permission role for display
+ */
+export function getRoleLabel(role) {
+    const labels = {
+        owner: "Owner",
+        organizer: "Organizer",
+        fileOrganizer: "File Organizer",
+        writer: "Editor",
+        commenter: "Commenter",
+        reader: "Viewer",
+    };
+    return labels[role] || role;
+}
+/**
+ * Format permission type for display
+ */
+export function getTypeLabel(type) {
+    const labels = {
+        user: "User",
+        group: "Group",
+        domain: "Domain",
+        anyone: "Anyone with link",
+    };
+    return labels[type] || type;
+}