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

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

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