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

package/dist/tools/drive/advanced/drive_list_revisions.js

@@ -0,0 +1,80 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { formatRevisionList, } from "../../../lib/drive-helpers.js";
+export const schema = {
+    name: "drive_list_revisions",
+    description: "List all revisions of a file in Google Drive. Shows revision history with timestamps and modification details. Supports pagination.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            fileId: {
+                type: "string",
+                description: "ID of the file to list revisions for",
+            },
+            pageSize: {
+                type: "number",
+                description: "Maximum number of revisions to return per page (default: 10, max: 1000)",
+                optional: true,
+            },
+            pageToken: {
+                type: "string",
+                description: "Token for pagination to get the next page of results",
+                optional: true,
+            },
+        },
+        required: ["fileId"],
+    },
+};
+export async function listRevisions(args) {
+    try {
+        const drive = google.drive("v3");
+        const { fileId, pageSize = 10, pageToken } = args;
+        // Get file metadata
+        const fileResponse = await drive.files.get({
+            fileId,
+            fields: "id, name, mimeType, size, modifiedTime, createdTime",
+        });
+        const file = fileResponse.data;
+        // List revisions
+        const revisionsResponse = await drive.revisions.list({
+            fileId,
+            pageSize: Math.min(pageSize, 1000), // Cap at 1000
+            pageToken: pageToken || undefined,
+            fields: "revisions(id, modifiedTime, lastModifyingUser, size, keepForever, originalFilename, mimeType), nextPageToken",
+        });
+        const revisions = revisionsResponse.data.revisions || [];
+        const nextPageToken = revisionsResponse.data.nextPageToken;
+        // Format output
+        let output = `📄 Revision History for "${file.name}"\n`;
+        output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+        output += `Total Revisions: ${revisions.length}\n`;
+        if (nextPageToken) {
+            output += `(More revisions available - use nextPageToken for pagination)\n`;
+        }
+        output += `\n${formatRevisionList(revisions)}\n`;
+        // Format detailed output for each revision
+        let detailedRevisions = revisions.map((revision, index) => ({
+            index: index + 1,
+            revisionId: revision.id || "",
+            modifiedTime: revision.modifiedTime || "Unknown",
+            modifiedBy: revision.lastModifyingUser?.displayName || "Unknown",
+            modifiedByEmail: revision.lastModifyingUser?.emailAddress || "Unknown",
+            size: revision.size ? parseInt(revision.size) : 0,
+            mimeType: revision.mimeType || "Unknown",
+            keepForever: revision.keepForever || false,
+            originalFilename: revision.originalFilename || file.name,
+        }));
+        return ResponseFormatter.success({
+            fileId,
+            fileName: file.name,
+            totalRevisions: revisions.length,
+            revisions: detailedRevisions,
+            nextPageToken: nextPageToken || null,
+            hasMoreResults: !!nextPageToken,
+            pageSize,
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/drive/basic/drive_get_metadata.js

@@ -0,0 +1,49 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { formatFileMetadata } from "../../../lib/drive-helpers.js";
+export const schema = {
+    name: "drive_get_metadata",
+    description: "Get detailed metadata for a specific file in Google Drive. Returns file ID, name, MIME type, size, created/modified times, sharing settings, and more.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            fileId: {
+                type: "string",
+                description: "ID of the file to get metadata for",
+            },
+            fields: {
+                type: "string",
+                description: "Comma-separated list of fields to include (default: all common fields)",
+                optional: true,
+            },
+        },
+        required: ["fileId"],
+    },
+};
+export async function getMetadata(args) {
+    try {
+        const drive = google.drive("v3");
+        const { fileId, fields } = args;
+        const defaultFields = "id, name, mimeType, size, createdTime, modifiedTime, modifiedByMe, owners, lastModifyingUser, shared, sharingUser, permissions, parents, webViewLink, webContentLink, iconLink, thumbnailLink, description, starred, trashed, explicitlyTrashed, properties, appProperties, spaces, version, teamDriveId, driveId, hasAugmentedPermissions, hasVersions, headRevisionId, copyRequiresWriterPermission, writersCanShare, folderColorRgb, originalFilename, fullFileExtension, fileExtension, md5Checksum, sha1Checksum, sha256Checksum";
+        const response = await drive.files.get({
+            fileId,
+            fields: fields || defaultFields,
+            supportsAllDrives: true,
+        });
+        const file = response.data;
+        const output = formatFileMetadata(file, true);
+        return ResponseFormatter.success({
+            fileId: file.id,
+            name: file.name,
+            mimeType: file.mimeType,
+            size: file.size,
+            createdTime: file.createdTime,
+            modifiedTime: file.modifiedTime,
+            webViewLink: file.webViewLink,
+            metadata: file,
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/drive/basic/drive_list_files.js

@@ -0,0 +1,76 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { formatFileList } from "../../../lib/drive-helpers.js";
+export const schema = {
+    name: "drive_list_files",
+    description: "List files in Google Drive. Supports filtering by query, folder, pagination, and sorting. Returns file IDs, names, types, and sizes.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "Search query using Google Drive query syntax (e.g., \"name contains 'report'\")",
+                optional: true,
+            },
+            folderId: {
+                type: "string",
+                description: "Folder ID to list files from (limits search to specific folder)",
+                optional: true,
+            },
+            pageSize: {
+                type: "number",
+                description: "Number of files 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: [],
+    },
+};
+export async function listFiles(args) {
+    try {
+        const drive = google.drive("v3");
+        const { query, folderId, pageSize = 100, pageToken, orderBy } = args;
+        // Build query
+        let q = "trashed = false";
+        if (query) {
+            q += ` and (${query})`;
+        }
+        if (folderId) {
+            q += ` and '${folderId}' in parents`;
+        }
+        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;
+        const output = formatFileList(files, nextPageToken);
+        return ResponseFormatter.success({
+            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/file/drive_copy_file.js

@@ -0,0 +1,79 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { formatFileMetadata, generateDriveWebUrl, } from "../../../lib/drive-helpers.js";
+export const schema = {
+    name: "drive_copy_file",
+    description: "Copy a file in Google Drive. Creates a duplicate of the file with optional new name and parent folder(s). Requires file ID.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            fileId: {
+                type: "string",
+                description: "ID of the file to copy",
+            },
+            name: {
+                type: "string",
+                description: "Name for the copied file (optional, defaults to 'Copy of [original name]')",
+                optional: true,
+            },
+            parents: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+                description: "Parent folder ID(s) for the copied file (optional, defaults to same location as original)",
+                optional: true,
+            },
+        },
+        required: ["fileId"],
+    },
+};
+export async function copyFile(args) {
+    try {
+        const drive = google.drive("v3");
+        const { fileId, name, parents } = args;
+        // Get original file metadata
+        const originalFile = await drive.files.get({
+            fileId,
+            fields: "id, name, mimeType",
+        });
+        const originalName = originalFile.data.name || "Unknown";
+        // Create copy metadata
+        const copyMetadata = {};
+        if (name) {
+            copyMetadata.name = name;
+        }
+        else {
+            copyMetadata.name = `Copy of ${originalName}`;
+        }
+        if (parents && parents.length > 0) {
+            copyMetadata.parents = parents;
+        }
+        // Copy the file
+        const response = await drive.files.copy({
+            fileId,
+            requestBody: copyMetadata,
+            fields: "id, name, mimeType, size, modifiedTime, webViewLink, parents",
+        });
+        const copiedFile = response.data;
+        const copiedFileId = copiedFile.id || "";
+        let output = `✅ File copied successfully!\n\n`;
+        output += `📄 Original: ${originalName} (${fileId})\n`;
+        output += `📄 Copy: ${copiedFile.name} (${copiedFileId})\n\n`;
+        output += formatFileMetadata(copiedFile, true);
+        output += `\n📎 Web URL: ${generateDriveWebUrl(copiedFileId)}\n`;
+        return ResponseFormatter.success({
+            originalFileId: fileId,
+            originalName,
+            copiedFileId,
+            copiedName: copiedFile.name,
+            mimeType: copiedFile.mimeType,
+            size: copiedFile.size,
+            webViewLink: copiedFile.webViewLink,
+            parents: copiedFile.parents,
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

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

@@ -0,0 +1,72 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { formatFileMetadata, generateDriveWebUrl, } from "../../../lib/drive-helpers.js";
+export const schema = {
+    name: "drive_create_file",
+    description: "Create an empty file or Google Workspace document in Google Drive. Creates a file with metadata only (no content). Use drive_upload_file if you need to include content.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "File name",
+            },
+            mimeType: {
+                type: "string",
+                description: "MIME type of the file (e.g., 'application/vnd.google-apps.document' for Google Docs, 'application/vnd.google-apps.spreadsheet' for Sheets)",
+            },
+            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"],
+    },
+};
+export async function createFile(args) {
+    try {
+        const drive = google.drive("v3");
+        const { name, mimeType, parents, description } = args;
+        // Create file metadata
+        const fileMetadata = {
+            name,
+            mimeType,
+        };
+        if (parents && parents.length > 0) {
+            fileMetadata.parents = parents;
+        }
+        if (description) {
+            fileMetadata.description = description;
+        }
+        // Create empty file
+        const response = await drive.files.create({
+            requestBody: fileMetadata,
+            fields: "id, name, mimeType, size, modifiedTime, webViewLink, parents",
+        });
+        const file = response.data;
+        const fileId = file.id || "";
+        let output = `✅ File created 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/file/drive_delete_file.js

@@ -0,0 +1,48 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+export const schema = {
+    name: "drive_delete_file",
+    description: "Delete a file from Google Drive. Moves the file to trash. To permanently delete, use drive_empty_trash. Requires file ID.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            fileId: {
+                type: "string",
+                description: "ID of the file to delete",
+            },
+        },
+        required: ["fileId"],
+    },
+};
+export async function deleteFile(args) {
+    try {
+        const drive = google.drive("v3");
+        const { fileId } = args;
+        // Get file metadata before deleting
+        const fileResponse = await drive.files.get({
+            fileId,
+            fields: "id, name, mimeType",
+        });
+        const fileName = fileResponse.data.name || "Unknown";
+        const mimeType = fileResponse.data.mimeType || "unknown";
+        // Delete the file (moves to trash)
+        await drive.files.delete({
+            fileId,
+        });
+        let output = `✅ File deleted successfully!\n\n`;
+        output += `📄 File Details:\n`;
+        output += `  Name: ${fileName}\n`;
+        output += `  ID: ${fileId}\n`;
+        output += `  MIME Type: ${mimeType}\n`;
+        output += `\nNote: File moved to trash. Use drive_empty_trash to permanently delete.`;
+        return ResponseFormatter.success({
+            fileId,
+            name: fileName,
+            mimeType,
+            deleted: true,
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

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

@@ -0,0 +1,79 @@
+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_file",
+    description: "Move a file to a different folder in Google Drive. Updates the file's parent folder(s). Can optionally remove from existing parent folders. Requires file ID and new parent folder ID(s).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            fileId: {
+                type: "string",
+                description: "ID of the file to move",
+            },
+            newParents: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+                description: "New parent folder ID(s) to move the file to",
+            },
+            removeParents: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+                description: "Parent folder ID(s) to remove the file from (optional, if not specified, removes from all current parents)",
+                optional: true,
+            },
+        },
+        required: ["fileId", "newParents"],
+    },
+};
+export async function moveFile(args) {
+    try {
+        const drive = google.drive("v3");
+        const { fileId, newParents, removeParents } = 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 || [];
+        // Determine which parents to remove
+        let parentsToRemove;
+        if (removeParents && removeParents.length > 0) {
+            parentsToRemove = removeParents;
+        }
+        else {
+            // Remove from all current parents if not specified
+            parentsToRemove = currentParents;
+        }
+        // Move the file
+        const response = await drive.files.update({
+            fileId,
+            addParents: newParents.join(","),
+            removeParents: parentsToRemove.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: ${newParents.join(", ")}\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/file/drive_rename_file.js

@@ -0,0 +1,58 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { formatFileMetadata, generateDriveWebUrl, } from "../../../lib/drive-helpers.js";
+export const schema = {
+    name: "drive_rename_file",
+    description: "Rename a file in Google Drive. Updates the file's name while keeping all other properties unchanged. Requires file ID and new name.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            fileId: {
+                type: "string",
+                description: "ID of the file to rename",
+            },
+            newName: {
+                type: "string",
+                description: "New name for the file",
+            },
+        },
+        required: ["fileId", "newName"],
+    },
+};
+export async function renameFile(args) {
+    try {
+        const drive = google.drive("v3");
+        const { fileId, newName } = args;
+        // Get current file metadata
+        const fileResponse = await drive.files.get({
+            fileId,
+            fields: "id, name, mimeType",
+        });
+        const oldName = fileResponse.data.name || "Unknown";
+        // Rename the file
+        const response = await drive.files.update({
+            fileId,
+            requestBody: {
+                name: newName,
+            },
+            fields: "id, name, mimeType, size, modifiedTime, webViewLink, parents",
+        });
+        const renamedFile = response.data;
+        let output = `✅ File renamed successfully!\n\n`;
+        output += `📄 Old Name: ${oldName}\n`;
+        output += `📄 New Name: ${newName}\n\n`;
+        output += formatFileMetadata(renamedFile, true);
+        output += `\n📎 Web URL: ${generateDriveWebUrl(fileId)}\n`;
+        return ResponseFormatter.success({
+            fileId,
+            oldName,
+            newName: renamedFile.name,
+            mimeType: renamedFile.mimeType,
+            size: renamedFile.size,
+            webViewLink: renamedFile.webViewLink,
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

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

@@ -0,0 +1,106 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { formatFileMetadata, generateDriveWebUrl, } from "../../../lib/drive-helpers.js";
+export const schema = {
+    name: "drive_update_file",
+    description: "Update a file's metadata and/or content in Google Drive. Can update name, description, MIME type, and content. All update fields are optional - only provide the fields you want to update.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            fileId: {
+                type: "string",
+                description: "ID of the file to update",
+            },
+            name: {
+                type: "string",
+                description: "New file name (optional)",
+                optional: true,
+            },
+            description: {
+                type: "string",
+                description: "New file description (optional)",
+                optional: true,
+            },
+            mimeType: {
+                type: "string",
+                description: "New MIME type (optional)",
+                optional: true,
+            },
+            content: {
+                type: "string",
+                description: "New file content (base64 encoded for binary files, plain text for text files) (optional)",
+                optional: true,
+            },
+        },
+        required: ["fileId"],
+    },
+};
+export async function updateFile(args) {
+    try {
+        const drive = google.drive("v3");
+        const { fileId, name, description, mimeType, content } = args;
+        // Get current file metadata
+        const fileResponse = await drive.files.get({
+            fileId,
+            fields: "id, name, description, mimeType",
+        });
+        const oldName = fileResponse.data.name || "Unknown";
+        const oldDescription = fileResponse.data.description || "";
+        const oldMimeType = fileResponse.data.mimeType || "unknown";
+        // Build update metadata
+        const updateMetadata = {};
+        const changes = [];
+        if (name !== undefined) {
+            updateMetadata.name = name;
+            changes.push(`Name: ${oldName} → ${name}`);
+        }
+        if (description !== undefined) {
+            updateMetadata.description = description;
+            changes.push(`Description: ${oldDescription || "(empty)"} → ${description}`);
+        }
+        if (mimeType !== undefined) {
+            updateMetadata.mimeType = mimeType;
+            changes.push(`MIME Type: ${oldMimeType} → ${mimeType}`);
+        }
+        // Update the file
+        const updateParams = {
+            fileId,
+            fields: "id, name, description, mimeType, size, modifiedTime, webViewLink, parents",
+        };
+        if (Object.keys(updateMetadata).length > 0) {
+            updateParams.requestBody = updateMetadata;
+        }
+        if (content !== undefined) {
+            updateParams.media = {
+                mimeType: mimeType || oldMimeType,
+                body: content,
+            };
+            changes.push("Content: Updated");
+        }
+        const response = await drive.files.update(updateParams);
+        const updatedFile = response.data;
+        let output = `✅ File updated successfully!\n\n`;
+        if (changes.length > 0) {
+            output += `📝 Changes:\n`;
+            changes.forEach((change) => {
+                output += `  • ${change}\n`;
+            });
+            output += `\n`;
+        }
+        output += formatFileMetadata(updatedFile, true);
+        output += `\n📎 Web URL: ${generateDriveWebUrl(fileId)}\n`;
+        return ResponseFormatter.success({
+            fileId,
+            name: updatedFile.name,
+            description: updatedFile.description,
+            mimeType: updatedFile.mimeType,
+            size: updatedFile.size,
+            modifiedTime: updatedFile.modifiedTime,
+            webViewLink: updatedFile.webViewLink,
+            changes,
+        }, output);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}