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

package/dist/tools/drive/folder/drive_move_to_folder.js

@@ -0,0 +1,59 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { formatFileMetadata, generateDriveWebUrl, } from "../../../lib/drive-helpers.js";
+export const schema = {
+    name: "drive_move_to_folder",
+    description: "Move a file to a specified folder in Google Drive. Removes the file from its current parent folder and adds it to the new folder. Requires file ID and folder ID.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            fileId: {
+                type: "string",
+                description: "ID of the file to move",
+            },
+            folderId: {
+                type: "string",
+                description: "ID of the destination folder",
+            },
+        },
+        required: ["fileId", "folderId"],
+    },
+};
+export async function moveToFolder(args) {
+    try {
+        const drive = google.drive("v3");
+        const { fileId, folderId } = args;
+        // Get current file metadata
+        const fileResponse = await drive.files.get({
+            fileId,
+            fields: "id, name, parents",
+        });
+        const fileName = fileResponse.data.name || "Unknown";
+        const currentParents = fileResponse.data.parents || [];
+        // Move the file to the new folder
+        const response = await drive.files.update({
+            fileId,
+            addParents: folderId,
+            removeParents: currentParents.join(","),
+            fields: "id, name, mimeType, size, modifiedTime, webViewLink, parents",
+        });
+        const movedFile = response.data;
+        let output = `✅ File moved successfully!\n\n`;
+        output += `📄 File: ${fileName}\n`;
+        output += `  From: ${currentParents.join(", ") || "Root"}\n`;
+        output += `  To: ${folderId}\n\n`;
+        output += formatFileMetadata(movedFile, true);
+        output += `\n📎 Web URL: ${generateDriveWebUrl(fileId)}\n`;
+        return ResponseFormatter.success({
+            fileId,
+            name: movedFile.name,
+            previousParents: currentParents,
+            newParents: movedFile.parents,
+            mimeType: movedFile.mimeType,
+            webViewLink: movedFile.webViewLink,
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/drive/permissions/drive_list_permissions.js

@@ -0,0 +1,115 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { getRoleLabel, getTypeLabel, } from "../../../lib/drive-helpers.js";
+export const schema = {
+    name: "drive_list_permissions",
+    description: "List all permissions for a Google Drive file. Shows who has access and what level of access they have.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            fileId: {
+                type: "string",
+                description: "ID of the file to get permissions for",
+            },
+        },
+        required: ["fileId"],
+    },
+};
+export async function listPermissions(args) {
+    try {
+        const drive = google.drive("v3");
+        const { fileId } = args;
+        // Get file metadata
+        const fileResponse = await drive.files.get({
+            fileId,
+            fields: "id, name, mimeType, webViewLink",
+        });
+        const fileName = fileResponse.data.name || "Unknown";
+        const webViewLink = fileResponse.data.webViewLink || "";
+        // List permissions
+        const permissionsResponse = await drive.permissions.list({
+            fileId,
+            fields: "permissions(id, type, role, emailAddress, displayName, domain, permissionDetails)",
+            pageSize: 100,
+        });
+        const permissions = permissionsResponse.data.permissions || [];
+        // Group permissions by type
+        const groupedPermissions = {
+            users: permissions.filter((p) => p.type === "user"),
+            groups: permissions.filter((p) => p.type === "group"),
+            domains: permissions.filter((p) => p.type === "domain"),
+            anyone: permissions.filter((p) => p.type === "anyone"),
+        };
+        let output = `📋 File Permissions\n`;
+        output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n`;
+        output += `📄 File: ${fileName}\n`;
+        output += `ID: ${fileId}\n`;
+        if (webViewLink) {
+            output += `Link: ${webViewLink}\n`;
+        }
+        output += `\n`;
+        // Display permissions by type
+        if (groupedPermissions.users.length > 0) {
+            output += `👤 Users (${groupedPermissions.users.length}):\n`;
+            groupedPermissions.users.forEach((p, i) => {
+                output += `  ${i + 1}. ${p.emailAddress || "Unknown"}\n`;
+                output += `     Role: ${getRoleLabel(p.role || "")}\n`;
+                output += `     Permission ID: ${p.id}\n\n`;
+            });
+        }
+        if (groupedPermissions.groups.length > 0) {
+            output += `👥 Groups (${groupedPermissions.groups.length}):\n`;
+            groupedPermissions.groups.forEach((p, i) => {
+                output += `  ${i + 1}. ${p.emailAddress || "Unknown"}\n`;
+                output += `     Role: ${getRoleLabel(p.role || "")}\n`;
+                output += `     Permission ID: ${p.id}\n\n`;
+            });
+        }
+        if (groupedPermissions.domains.length > 0) {
+            output += `🌐 Domains (${groupedPermissions.domains.length}):\n`;
+            groupedPermissions.domains.forEach((p, i) => {
+                output += `  ${i + 1}. ${p.domain || "Unknown"}\n`;
+                output += `     Role: ${getRoleLabel(p.role || "")}\n`;
+                output += `     Permission ID: ${p.id}\n\n`;
+            });
+        }
+        if (groupedPermissions.anyone.length > 0) {
+            output += `🌍 Anyone with Link (${groupedPermissions.anyone.length}):\n`;
+            groupedPermissions.anyone.forEach((p) => {
+                output += `  Role: ${getRoleLabel(p.role || "")}\n`;
+                output += `  Permission ID: ${p.id}\n\n`;
+            });
+        }
+        if (permissions.length === 0) {
+            output += `No permissions found.`;
+        }
+        else {
+            output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+            output += `Total: ${permissions.length} permission(s)`;
+        }
+        return ResponseFormatter.success({
+            fileId,
+            fileName,
+            totalPermissions: permissions.length,
+            permissions: permissions.map((p) => ({
+                id: p.id,
+                type: p.type,
+                role: p.role,
+                typeLabel: getTypeLabel(p.type || ""),
+                roleLabel: getRoleLabel(p.role || ""),
+                emailAddress: p.emailAddress,
+                displayName: p.displayName,
+                domain: p.domain,
+            })),
+            summary: {
+                users: groupedPermissions.users.length,
+                groups: groupedPermissions.groups.length,
+                domains: groupedPermissions.domains.length,
+                anyone: groupedPermissions.anyone.length,
+            },
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/drive/permissions/drive_remove_permission.js

@@ -0,0 +1,71 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { getTypeLabel } from "../../../lib/drive-helpers.js";
+export const schema = {
+    name: "drive_remove_permission",
+    description: "Remove a permission from a Google Drive file, revoking access for a user, group, domain, or link. Must specify the permission ID returned from list_permissions.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            fileId: {
+                type: "string",
+                description: "ID of the file to remove permission from",
+            },
+            permissionId: {
+                type: "string",
+                description: "ID of the permission to remove (get from drive_list_permissions)",
+            },
+        },
+        required: ["fileId", "permissionId"],
+    },
+};
+export async function removePermission(args) {
+    try {
+        const drive = google.drive("v3");
+        const { fileId, permissionId } = args;
+        // Get file metadata
+        const fileResponse = await drive.files.get({
+            fileId,
+            fields: "id, name, mimeType",
+        });
+        const fileName = fileResponse.data.name || "Unknown";
+        // Get permission details before removing (for display purposes)
+        const permissionResponse = await drive.permissions.get({
+            fileId,
+            permissionId,
+            fields: "id, type, role, emailAddress, displayName, domain",
+        });
+        const permission = permissionResponse.data;
+        const permissionType = permission.type || "unknown";
+        const recipientInfo = permission.emailAddress ||
+            permission.domain ||
+            permission.displayName ||
+            "Unknown";
+        // Delete permission
+        await drive.permissions.delete({
+            fileId,
+            permissionId,
+        });
+        let output = `✅ Permission removed successfully!\n\n`;
+        output += `📄 File Details:\n`;
+        output += `  Name: ${fileName}\n`;
+        output += `  ID: ${fileId}\n\n`;
+        output += `🔓 Removed Permission:\n`;
+        output += `  Permission ID: ${permissionId}\n`;
+        output += `  Type: ${getTypeLabel(permissionType)}\n`;
+        output += `  Recipient: ${recipientInfo}\n`;
+        output += `  Role: ${permission.role || "unknown"}\n`;
+        output += `\nAccess has been revoked.`;
+        return ResponseFormatter.success({
+            fileId,
+            fileName,
+            permissionId,
+            removedPermissionType: permissionType,
+            recipient: recipientInfo,
+            role: permission.role,
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/drive/permissions/drive_share_file.js

@@ -0,0 +1,116 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { formatPermission } from "../../../lib/drive-helpers.js";
+export const schema = {
+    name: "drive_share_file",
+    description: "Share a file on Google Drive by adding permissions. Supports sharing with users, groups, domains, or anyone with the link. Can optionally send notification emails.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            fileId: {
+                type: "string",
+                description: "ID of the file to share",
+            },
+            role: {
+                type: "string",
+                enum: ["owner", "organizer", "fileOrganizer", "writer", "commenter", "reader"],
+                description: "Permission role: owner (full control), writer (editor), commenter (comment only), reader (viewer)",
+            },
+            type: {
+                type: "string",
+                enum: ["user", "group", "domain", "anyone"],
+                description: "Type of recipient: user (email), group (group email), domain (entire domain), anyone (anyone with link)",
+            },
+            emailAddress: {
+                type: "string",
+                description: "Email address (required for type=user or type=group)",
+                optional: true,
+            },
+            domain: {
+                type: "string",
+                description: "Domain name (required for type=domain, e.g., 'example.com')",
+                optional: true,
+            },
+            sendNotificationEmail: {
+                type: "boolean",
+                description: "Send notification email to the recipient(s). Default: true",
+                optional: true,
+            },
+            emailMessage: {
+                type: "string",
+                description: "Custom message to include in notification email",
+                optional: true,
+            },
+        },
+        required: ["fileId", "role", "type"],
+    },
+};
+export async function shareFile(args) {
+    try {
+        const drive = google.drive("v3");
+        const { fileId, role, type, emailAddress, domain, sendNotificationEmail = true, emailMessage, } = args;
+        // Validate required fields based on type
+        if (type === "user" || type === "group") {
+            if (!emailAddress) {
+                return ResponseFormatter.error(`emailAddress is required for type='${type}'`);
+            }
+        }
+        if (type === "domain") {
+            if (!domain) {
+                return ResponseFormatter.error("domain is required for type='domain'");
+            }
+        }
+        // Get file metadata
+        const fileResponse = await drive.files.get({
+            fileId,
+            fields: "id, name, mimeType",
+        });
+        const fileName = fileResponse.data.name || "Unknown";
+        // Create permission object
+        const permissionBody = {
+            role,
+            type,
+        };
+        if (emailAddress) {
+            permissionBody.emailAddress = emailAddress;
+        }
+        if (domain) {
+            permissionBody.domain = domain;
+        }
+        // Add permission
+        const permissionResponse = await drive.permissions.create({
+            fileId,
+            requestBody: permissionBody,
+            fields: "id, role, type, emailAddress, displayName, domain, permissionDetails",
+            sendNotificationEmail,
+            emailMessage: emailMessage || undefined,
+        });
+        const permission = permissionResponse.data;
+        const permissionId = permission.id || "";
+        let output = `✅ File shared successfully!\n\n`;
+        output += `📄 File Details:\n`;
+        output += `  Name: ${fileName}\n`;
+        output += `  ID: ${fileId}\n\n`;
+        output += `🔗 Permission Details:\n`;
+        output += formatPermission(permission);
+        if (sendNotificationEmail) {
+            output += `\n📧 Notification email sent`;
+            if (emailMessage) {
+                output += ` with custom message`;
+            }
+        }
+        return ResponseFormatter.success({
+            fileId,
+            fileName,
+            permissionId,
+            role,
+            type,
+            emailAddress: emailAddress || undefined,
+            domain: domain || undefined,
+            notificationSent: sendNotificationEmail,
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/drive/permissions/drive_update_permission.js

@@ -0,0 +1,79 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { formatPermission, getRoleLabel } from "../../../lib/drive-helpers.js";
+export const schema = {
+    name: "drive_update_permission",
+    description: "Update an existing permission on a Google Drive file. Allows changing the role (access level) for a user, group, domain, or link. Must specify the permission ID returned from list_permissions.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            fileId: {
+                type: "string",
+                description: "ID of the file whose permission to update",
+            },
+            permissionId: {
+                type: "string",
+                description: "ID of the permission to update (get from drive_list_permissions)",
+            },
+            role: {
+                type: "string",
+                enum: ["owner", "organizer", "fileOrganizer", "writer", "commenter", "reader"],
+                description: "New permission role: owner (full control), writer (editor), commenter (comment only), reader (viewer)",
+            },
+        },
+        required: ["fileId", "permissionId", "role"],
+    },
+};
+export async function updatePermission(args) {
+    try {
+        const drive = google.drive("v3");
+        const { fileId, permissionId, role } = args;
+        // Get file metadata
+        const fileResponse = await drive.files.get({
+            fileId,
+            fields: "id, name, mimeType",
+        });
+        const fileName = fileResponse.data.name || "Unknown";
+        // Get current permission to show what changed
+        const currentPermissionResponse = await drive.permissions.get({
+            fileId,
+            permissionId,
+            fields: "id, type, role, emailAddress, displayName, domain",
+        });
+        const currentPermission = currentPermissionResponse.data;
+        const oldRole = currentPermission.role || "";
+        // Update permission
+        const updateResponse = await drive.permissions.update({
+            fileId,
+            permissionId,
+            requestBody: {
+                role,
+            },
+            fields: "id, role, type, emailAddress, displayName, domain, permissionDetails",
+        });
+        const updatedPermission = updateResponse.data;
+        let output = `✅ Permission updated successfully!\n\n`;
+        output += `📄 File Details:\n`;
+        output += `  Name: ${fileName}\n`;
+        output += `  ID: ${fileId}\n\n`;
+        output += `🔄 Changes Made:\n`;
+        output += `  Permission ID: ${permissionId}\n`;
+        output += `  Previous Role: ${getRoleLabel(oldRole)}\n`;
+        output += `  New Role: ${getRoleLabel(role)}\n\n`;
+        output += `📋 Updated Permission Details:\n`;
+        output += formatPermission(updatedPermission);
+        return ResponseFormatter.success({
+            fileId,
+            fileName,
+            permissionId,
+            previousRole: oldRole,
+            newRole: role,
+            recipientType: currentPermission.type,
+            recipientEmail: currentPermission.emailAddress,
+            recipientDomain: currentPermission.domain,
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/gmail/basic/gmail_get_message.js

@@ -0,0 +1,95 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { extractMessageBodies, formatBodyContent, extractAttachments, getHeader, generateGmailWebUrl, } from "../../../lib/gmail-helpers.js";
+export const schema = {
+    name: "gmail_get_message",
+    description: "Retrieve full content of a specific Gmail message including subject, sender, recipients, body (text/HTML), and attachments. Returns formatted message with metadata.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            messageId: {
+                type: "string",
+                description: "The Gmail message ID to retrieve",
+            },
+        },
+        required: ["messageId"],
+    },
+};
+export async function getMessage(args) {
+    try {
+        const gmail = google.gmail("v1");
+        const { messageId } = args;
+        // Fetch message with full format
+        const response = await gmail.users.messages.get({
+            userId: "me",
+            id: messageId,
+            format: "full",
+        });
+        const message = response.data;
+        const headers = message.payload?.headers || [];
+        // Extract metadata
+        const subject = getHeader(headers, "Subject");
+        const from = getHeader(headers, "From");
+        const to = getHeader(headers, "To");
+        const cc = getHeader(headers, "Cc");
+        const date = getHeader(headers, "Date");
+        const messageIdHeader = getHeader(headers, "Message-ID");
+        // Extract body
+        const { textBody, htmlBody } = extractMessageBodies(message.payload || {});
+        const bodyContent = formatBodyContent(textBody, htmlBody);
+        // Extract attachments
+        const attachments = extractAttachments(message.payload || {});
+        // Build output
+        let output = `Message ID: ${messageId}\n`;
+        output += `Thread ID: ${message.threadId}\n`;
+        output += `Web URL: ${generateGmailWebUrl(messageId)}\n\n`;
+        output += `Subject: ${subject}\n`;
+        output += `From: ${from}\n`;
+        output += `To: ${to}\n`;
+        if (cc)
+            output += `Cc: ${cc}\n`;
+        output += `Date: ${date}\n`;
+        if (messageIdHeader)
+            output += `Message-ID: ${messageIdHeader}\n`;
+        output += `\n${"=".repeat(80)}\n\n`;
+        // Truncate very long bodies
+        const maxBodyLength = 20000;
+        if (bodyContent.length > maxBodyLength) {
+            output += bodyContent.substring(0, maxBodyLength);
+            output += `\n\n[... truncated ${bodyContent.length - maxBodyLength} characters ...]`;
+        }
+        else {
+            output += bodyContent;
+        }
+        // Add attachments info
+        if (attachments.length > 0) {
+            output += `\n\n${"=".repeat(80)}\n\n`;
+            output += `📎 Attachments (${attachments.length}):\n`;
+            attachments.forEach((att, index) => {
+                output += `  ${index + 1}. ${att.filename} (${att.mimeType}, ${Math.round(att.size / 1024)}KB)\n`;
+                output += `     Attachment ID: ${att.attachmentId}\n`;
+            });
+            output += `\nUse 'gmail_get_attachment' tool to download attachments.\n`;
+        }
+        return ResponseFormatter.success({
+            messageId,
+            threadId: message.threadId,
+            subject,
+            from,
+            to,
+            cc,
+            date,
+            labels: message.labelIds,
+            attachments: attachments.map((a) => ({
+                filename: a.filename,
+                mimeType: a.mimeType,
+                size: a.size,
+                attachmentId: a.attachmentId,
+            })),
+            snippet: message.snippet,
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/gmail/basic/gmail_get_thread.js

@@ -0,0 +1,46 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { formatThreadContent } from "../../../lib/gmail-helpers.js";
+export const schema = {
+    name: "gmail_get_thread",
+    description: "Retrieve a complete Gmail thread (conversation) with all messages. Returns all messages in chronological order with full content, metadata, and attachments.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            threadId: {
+                type: "string",
+                description: "The Gmail thread ID to retrieve",
+            },
+        },
+        required: ["threadId"],
+    },
+};
+export async function getThread(args) {
+    try {
+        const gmail = google.gmail("v1");
+        const { threadId } = args;
+        // Fetch thread with full format
+        const response = await gmail.users.threads.get({
+            userId: "me",
+            id: threadId,
+            format: "full",
+        });
+        const thread = response.data;
+        const messages = thread.messages || [];
+        // Format thread content using helper
+        const formattedContent = formatThreadContent(thread);
+        // Build metadata for structured response
+        const messageCount = messages.length;
+        const messageIds = messages.map((m) => m.id);
+        const snippets = messages.map((m) => m.snippet || "");
+        return ResponseFormatter.success({
+            threadId,
+            messageCount,
+            messageIds,
+            snippets,
+        }, formattedContent);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/gmail/basic/gmail_list_labels.js

@@ -0,0 +1,54 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+export const schema = {
+    name: "gmail_list_labels",
+    description: "List all labels in the user's Gmail account. Returns both system labels (INBOX, SENT, TRASH, etc.) and user-created labels with their IDs and names.",
+    inputSchema: {
+        type: "object",
+        properties: {},
+        required: [],
+    },
+};
+export async function listLabels(args) {
+    try {
+        const gmail = google.gmail("v1");
+        const response = await gmail.users.labels.list({
+            userId: "me",
+        });
+        const labels = response.data.labels || [];
+        if (labels.length === 0) {
+            return ResponseFormatter.success({ count: 0, labels: [] }, "No labels found in Gmail account");
+        }
+        // Separate system and user labels
+        const systemLabels = labels.filter((l) => l.type === "system");
+        const userLabels = labels.filter((l) => l.type === "user");
+        let output = `Total labels: ${labels.length}\n\n`;
+        if (systemLabels.length > 0) {
+            output += `📌 System Labels (${systemLabels.length}):\n`;
+            systemLabels.forEach((label) => {
+                output += `  - ${label.name} (ID: ${label.id})\n`;
+            });
+            output += `\n`;
+        }
+        if (userLabels.length > 0) {
+            output += `🏷️  User Labels (${userLabels.length}):\n`;
+            userLabels.forEach((label) => {
+                output += `  - ${label.name} (ID: ${label.id})\n`;
+            });
+        }
+        return ResponseFormatter.success({
+            count: labels.length,
+            systemLabels: systemLabels.map((l) => ({
+                id: l.id,
+                name: l.name,
+            })),
+            userLabels: userLabels.map((l) => ({
+                id: l.id,
+                name: l.name,
+            })),
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}