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

package/dist/tools/drive/file/drive_upload_file.js

@@ -0,0 +1,80 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { formatFileMetadata, generateDriveWebUrl, } from "../../../lib/drive-helpers.js";
+export const schema = {
+    name: "drive_upload_file",
+    description: "Upload a file to Google Drive with content. Creates a new file with the specified name, MIME type, and content. Optionally specify parent folder(s) and description.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "File name",
+            },
+            mimeType: {
+                type: "string",
+                description: "MIME type of the file (e.g., 'text/plain', 'application/json', 'image/png')",
+            },
+            content: {
+                type: "string",
+                description: "File content (base64 encoded for binary files, plain text for text files)",
+            },
+            parents: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+                description: "Parent folder ID(s) where the file should be created",
+                optional: true,
+            },
+            description: {
+                type: "string",
+                description: "File description",
+                optional: true,
+            },
+        },
+        required: ["name", "mimeType", "content"],
+    },
+};
+export async function uploadFile(args) {
+    try {
+        const drive = google.drive("v3");
+        const { name, mimeType, content, parents, description } = args;
+        // Create file metadata
+        const fileMetadata = {
+            name,
+            mimeType,
+        };
+        if (parents && parents.length > 0) {
+            fileMetadata.parents = parents;
+        }
+        if (description) {
+            fileMetadata.description = description;
+        }
+        // Upload file with content
+        const response = await drive.files.create({
+            requestBody: fileMetadata,
+            media: {
+                mimeType,
+                body: content,
+            },
+            fields: "id, name, mimeType, size, modifiedTime, webViewLink, parents",
+        });
+        const file = response.data;
+        const fileId = file.id || "";
+        let output = `✅ File uploaded successfully!\n\n`;
+        output += formatFileMetadata(file, true);
+        output += `\n📎 Web URL: ${generateDriveWebUrl(fileId)}\n`;
+        return ResponseFormatter.success({
+            fileId,
+            name: file.name,
+            mimeType: file.mimeType,
+            size: file.size,
+            webViewLink: file.webViewLink,
+            parents: file.parents,
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

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

@@ -0,0 +1,67 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { formatFileMetadata, generateFolderWebUrl, FOLDER_MIME_TYPE, } from "../../../lib/drive-helpers.js";
+export const schema = {
+    name: "drive_create_folder",
+    description: "Create a new folder in Google Drive. Can optionally place the folder inside a parent folder. Returns folder ID and metadata.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Folder name",
+            },
+            parents: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+                description: "Parent folder ID(s) where the folder should be created (optional)",
+                optional: true,
+            },
+            description: {
+                type: "string",
+                description: "Folder description",
+                optional: true,
+            },
+        },
+        required: ["name"],
+    },
+};
+export async function createFolder(args) {
+    try {
+        const drive = google.drive("v3");
+        const { name, parents, description } = args;
+        // Create folder metadata
+        const folderMetadata = {
+            name,
+            mimeType: FOLDER_MIME_TYPE,
+        };
+        if (parents && parents.length > 0) {
+            folderMetadata.parents = parents;
+        }
+        if (description) {
+            folderMetadata.description = description;
+        }
+        // Create folder
+        const response = await drive.files.create({
+            requestBody: folderMetadata,
+            fields: "id, name, mimeType, modifiedTime, webViewLink, parents",
+        });
+        const folder = response.data;
+        const folderId = folder.id || "";
+        let output = `✅ Folder created successfully!\n\n`;
+        output += formatFileMetadata(folder, true);
+        output += `\n📂 Web URL: ${generateFolderWebUrl(folderId)}\n`;
+        return ResponseFormatter.success({
+            folderId,
+            name: folder.name,
+            mimeType: folder.mimeType,
+            webViewLink: folder.webViewLink,
+            parents: folder.parents,
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

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

@@ -0,0 +1,68 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { formatFileList } from "../../../lib/drive-helpers.js";
+export const schema = {
+    name: "drive_list_folder_contents",
+    description: "List all files and folders inside a specific folder in Google Drive. Supports pagination and sorting. Returns file IDs, names, types, and sizes.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            folderId: {
+                type: "string",
+                description: "ID of the folder to list contents from",
+            },
+            pageSize: {
+                type: "number",
+                description: "Number of items to return per page (max 1000, default 100)",
+                optional: true,
+            },
+            pageToken: {
+                type: "string",
+                description: "Page token for pagination",
+                optional: true,
+            },
+            orderBy: {
+                type: "string",
+                description: "Sort order (e.g., 'name', 'modifiedTime desc', 'createdTime')",
+                optional: true,
+            },
+        },
+        required: ["folderId"],
+    },
+};
+export async function listFolderContents(args) {
+    try {
+        const drive = google.drive("v3");
+        const { folderId, pageSize = 100, pageToken, orderBy } = args;
+        // Build query for folder contents
+        const q = `'${folderId}' in parents and trashed = false`;
+        const response = await drive.files.list({
+            q,
+            pageSize: Math.min(pageSize, 1000),
+            pageToken,
+            orderBy: orderBy || "modifiedTime desc",
+            fields: "nextPageToken, files(id, name, mimeType, size, modifiedTime, createdTime, webViewLink, parents, iconLink)",
+        });
+        const files = response.data.files || [];
+        const nextPageToken = response.data.nextPageToken;
+        let output = `📁 Folder Contents\n`;
+        output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+        output += `Folder ID: ${folderId}\n\n`;
+        output += formatFileList(files, nextPageToken);
+        return ResponseFormatter.success({
+            folderId,
+            count: files.length,
+            files: files.map((f) => ({
+                id: f.id,
+                name: f.name,
+                mimeType: f.mimeType,
+                size: f.size,
+                modifiedTime: f.modifiedTime,
+            })),
+            nextPageToken,
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

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);
+    }
+}