google-tools-mcp 1.0.0

package/dist/tools/drive/renameFile.js

@@ -0,0 +1,39 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDriveClient } from '../../clients.js';
+export function register(server) {
+    server.addTool({
+        name: 'renameFile',
+        description: 'Renames a file or folder in Google Drive. Returns the updated file info.',
+        parameters: z.object({
+            fileId: z
+                .string()
+                .describe('The file or folder ID from a Google Drive URL or a previous tool result.'),
+            newName: z.string().min(1).describe('New name for the file or folder.'),
+        }),
+        execute: async (args, { log }) => {
+            const drive = await getDriveClient();
+            log.info(`Renaming file ${args.fileId} to "${args.newName}"`);
+            try {
+                const response = await drive.files.update({
+                    fileId: args.fileId,
+                    requestBody: {
+                        name: args.newName,
+                    },
+                    fields: 'id,name,webViewLink',
+                    supportsAllDrives: true,
+                });
+                const file = response.data;
+                return `Successfully renamed to "${file.name}" (ID: ${file.id})\nLink: ${file.webViewLink}`;
+            }
+            catch (error) {
+                log.error(`Error renaming file: ${error.message || error}`);
+                if (error.code === 404)
+                    throw new UserError('File not found. Check the file ID.');
+                if (error.code === 403)
+                    throw new UserError('Permission denied. Make sure you have write access to this file.');
+                throw new UserError(`Failed to rename file: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/drive/searchGoogleDocs.js

@@ -0,0 +1,98 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDriveClient } from '../../clients.js';
+export function register(server) {
+    server.addTool({
+        name: 'searchDocuments',
+        description: 'Searches for documents by name, content, or both. Finds Google Docs, Word (.docx), and PDF files. Use listDocuments for browsing and this tool for targeted queries.',
+        parameters: z.object({
+            query: z.string().min(1).describe('Search term to find in document names or content.'),
+            searchIn: z
+                .enum(['name', 'content', 'both'])
+                .optional()
+                .default('both')
+                .describe('Where to search: document names, content, or both.'),
+            fileType: z
+                .enum(['all', 'google-doc', 'docx', 'pdf'])
+                .optional()
+                .default('all')
+                .describe('Filter by file type: all document types, Google Docs only, Word (.docx) only, or PDF only.'),
+            maxResults: z
+                .number()
+                .int()
+                .min(1)
+                .max(50)
+                .optional()
+                .default(10)
+                .describe('Maximum number of results to return.'),
+            modifiedAfter: z
+                .string()
+                .optional()
+                .describe('Only return documents modified after this date (ISO 8601 format, e.g., "2024-01-01").'),
+        }),
+        execute: async (args, { log }) => {
+            const drive = await getDriveClient();
+            log.info(`Searching Google Docs for: "${args.query}" in ${args.searchIn}`);
+            try {
+                const mimeTypes = {
+                    'google-doc': ["mimeType='application/vnd.google-apps.document'"],
+                    'docx': ["mimeType='application/vnd.openxmlformats-officedocument.wordprocessingml.document'"],
+                    'pdf': ["mimeType='application/pdf'"],
+                    'all': [
+                        "mimeType='application/vnd.google-apps.document'",
+                        "mimeType='application/vnd.openxmlformats-officedocument.wordprocessingml.document'",
+                        "mimeType='application/pdf'",
+                    ],
+                };
+                const selectedMimes = mimeTypes[args.fileType || 'all'];
+                const mimeFilter = selectedMimes.length === 1
+                    ? selectedMimes[0]
+                    : `(${selectedMimes.join(' or ')})`;
+                let queryString = `${mimeFilter} and trashed=false`;
+                // Add search criteria
+                if (args.searchIn === 'name') {
+                    queryString += ` and name contains '${args.query}'`;
+                }
+                else if (args.searchIn === 'content') {
+                    queryString += ` and fullText contains '${args.query}'`;
+                }
+                else {
+                    queryString += ` and (name contains '${args.query}' or fullText contains '${args.query}')`;
+                }
+                // Add date filter if provided
+                if (args.modifiedAfter) {
+                    queryString += ` and modifiedTime > '${args.modifiedAfter}'`;
+                }
+                const response = await drive.files.list({
+                    q: queryString,
+                    pageSize: args.maxResults,
+                    orderBy: 'modifiedTime desc',
+                    fields: 'files(id,name,mimeType,modifiedTime,createdTime,webViewLink,owners(displayName),parents)',
+                    supportsAllDrives: true,
+                    includeItemsFromAllDrives: true,
+                });
+                const files = response.data.files || [];
+                const mimeToType = {
+                    'application/vnd.google-apps.document': 'google-doc',
+                    'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'docx',
+                    'application/pdf': 'pdf',
+                };
+                const documents = files.map((file) => ({
+                    id: file.id,
+                    name: file.name,
+                    type: mimeToType[file.mimeType] || file.mimeType,
+                    modifiedTime: file.modifiedTime,
+                    owner: file.owners?.[0]?.displayName || null,
+                    url: file.webViewLink,
+                }));
+                return JSON.stringify({ documents }, null, 2);
+            }
+            catch (error) {
+                log.error(`Error searching Google Docs: ${error.message || error}`);
+                if (error.code === 403)
+                    throw new UserError('Permission denied. Make sure you have granted Google Drive access to the application.');
+                throw new UserError(`Failed to search documents: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/extras/index.js

@@ -0,0 +1,7 @@
+import { register as readFile } from './readFile.js';
+import { register as searchFileContents } from './searchFileContents.js';
+
+export function registerExtrasTools(server) {
+    readFile(server);
+    searchFileContents(server);
+}

package/dist/tools/extras/readFile.js

@@ -0,0 +1,82 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDriveClient } from '../../clients.js';
+import mammoth from 'mammoth';
+
+function isDocx(mimeType, name) {
+    return (
+        mimeType === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' ||
+        (name && name.endsWith('.docx'))
+    );
+}
+
+function isPdf(mimeType, name) {
+    return mimeType === 'application/pdf' || (name && name.endsWith('.pdf'));
+}
+
+async function downloadBuffer(drive, fileId) {
+    const response = await drive.files.get(
+        { fileId, alt: 'media', supportsAllDrives: true },
+        { responseType: 'arraybuffer' }
+    );
+    return Buffer.from(response.data);
+}
+
+export async function extractText(buffer, mimeType, name) {
+    if (isDocx(mimeType, name)) {
+        const result = await mammoth.extractRawText({ buffer });
+        return result.value;
+    }
+    if (isPdf(mimeType, name)) {
+        const { default: pdfParse } = await import('pdf-parse/lib/pdf-parse.js');
+        const result = await pdfParse(buffer);
+        return result.text;
+    }
+    return null;
+}
+
+export { isDocx, isPdf, downloadBuffer };
+
+export function register(server) {
+    server.addTool({
+        name: 'readFile',
+        description:
+            'Read the full text content of a .docx or .pdf file from Google Drive by file ID. ' +
+            'Use this for Word documents and PDFs that cannot be read with readDocument.',
+        parameters: z.object({
+            fileId: z.string().describe('The Google Drive file ID'),
+        }),
+        execute: async ({ fileId }, { log }) => {
+            const drive = await getDriveClient();
+            log.info(`Reading file ${fileId}`);
+
+            try {
+                const meta = await drive.files.get({
+                    fileId,
+                    fields: 'name,mimeType',
+                    supportsAllDrives: true,
+                });
+
+                const { name, mimeType } = meta.data;
+                const buffer = await downloadBuffer(drive, fileId);
+                const text = await extractText(buffer, mimeType, name);
+
+                if (text === null) {
+                    throw new UserError(
+                        `Unsupported file type: ${mimeType} (${name}). Only .docx and .pdf are supported.`
+                    );
+                }
+
+                return `# ${name}\n\n${text}`;
+            } catch (error) {
+                if (error instanceof UserError) throw error;
+                log.error(`Error reading file: ${error.message}`);
+                if (error.code === 404)
+                    throw new UserError(`File not found: ${fileId}`);
+                if (error.code === 403)
+                    throw new UserError('Permission denied. Check that the file is shared with this account.');
+                throw new UserError(`Failed to read file: ${error.message}`);
+            }
+        },
+    });
+}

package/dist/tools/extras/searchFileContents.js

@@ -0,0 +1,81 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDriveClient } from '../../clients.js';
+import { isDocx, isPdf, downloadBuffer, extractText } from './readFile.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'searchFileContents',
+        description:
+            'Search Google Drive for files whose content or name matches a query. ' +
+            'For .docx and .pdf files, extracts and returns matching text snippets. ' +
+            'Use this to find information inside Office documents and PDFs.',
+        parameters: z.object({
+            query: z.string().describe('Text to search for'),
+            maxResults: z
+                .number()
+                .optional()
+                .default(5)
+                .describe('Max number of files to search (default 5)'),
+            folderId: z
+                .string()
+                .optional()
+                .describe('Restrict search to a specific folder ID'),
+        }),
+        execute: async ({ query, maxResults = 5, folderId }, { log }) => {
+            const drive = await getDriveClient();
+            log.info(`Searching file contents for: "${query}"`);
+
+            try {
+                const escaped = query.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+                let q = `fullText contains '${escaped}' and trashed = false`;
+                if (folderId) q += ` and '${folderId}' in parents`;
+
+                const response = await drive.files.list({
+                    q,
+                    pageSize: maxResults,
+                    fields: 'files(id,name,mimeType)',
+                    supportsAllDrives: true,
+                    includeItemsFromAllDrives: true,
+                });
+
+                const files = response.data.files || [];
+                if (files.length === 0) return 'No files found matching that query.';
+
+                const results = [];
+
+                for (const file of files) {
+                    const canRead = isDocx(file.mimeType, file.name) || isPdf(file.mimeType, file.name);
+
+                    if (canRead) {
+                        try {
+                            const buffer = await downloadBuffer(drive, file.id);
+                            const text = await extractText(buffer, file.mimeType, file.name);
+
+                            const lowerText = text.toLowerCase();
+                            const lowerQuery = query.toLowerCase();
+                            const idx = lowerText.indexOf(lowerQuery);
+                            const snippet =
+                                idx !== -1
+                                    ? '...' + text.slice(Math.max(0, idx - 150), idx + 300).trim() + '...'
+                                    : text.slice(0, 400).trim() + '...';
+
+                            results.push(`**${file.name}** (ID: \`${file.id}\`)\n\n${snippet}`);
+                        } catch (e) {
+                            results.push(`**${file.name}** (ID: \`${file.id}\`)\n\n[Could not read: ${e.message}]`);
+                        }
+                    } else {
+                        results.push(`**${file.name}** (ID: \`${file.id}\`, type: ${file.mimeType})`);
+                    }
+                }
+
+                return results.join('\n\n---\n\n');
+            } catch (error) {
+                log.error(`Error searching files: ${error.message}`);
+                if (error.code === 403)
+                    throw new UserError('Permission denied. Check Drive access.');
+                throw new UserError(`Failed to search files: ${error.message}`);
+            }
+        },
+    });
+}

package/dist/tools/gmail/drafts.js

@@ -0,0 +1,165 @@
+// Gmail Draft tools
+import { z } from 'zod';
+import { UserError } from 'fastmcp';
+import { getGmailClient } from '../../clients.js';
+import { processMessagePart, constructRawMessage, constructRawMessageWithAttachments } from '../../helpers.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'create_draft',
+        description: 'Create a draft email in Gmail. Note the mechanics of the raw parameter.',
+        parameters: z.object({
+            raw: z.string().optional().describe("The entire email message in base64url encoded RFC 2822 format, ignores params.to, cc, bcc, subject, body, includeBodyHtml if provided"),
+            threadId: z.string().optional().describe("The thread ID to associate this draft with"),
+            to: z.array(z.string()).optional().describe("List of recipient email addresses"),
+            cc: z.array(z.string()).optional().describe("List of CC recipient email addresses"),
+            bcc: z.array(z.string()).optional().describe("List of BCC recipient email addresses"),
+            subject: z.string().optional().describe("The subject of the email"),
+            body: z.string().optional().describe("The body of the email"),
+            attachments: z.array(z.object({
+                filename: z.string().describe("Attachment file name"),
+                mimeType: z.string().describe("MIME type of the attachment"),
+                base64Data: z.string().describe("Base64 encoded attachment data"),
+            })).optional().describe("File attachments to include"),
+            includeBodyHtml: z.boolean().optional().describe("Whether to include the parsed HTML in the return for each body"),
+        }),
+        execute: async (params, { log }) => {
+            const gmail = await getGmailClient();
+            let raw = params.raw;
+            if (!raw) {
+                if (params.attachments?.length) {
+                    raw = await constructRawMessageWithAttachments(gmail, params);
+                } else {
+                    raw = await constructRawMessage(gmail, params);
+                }
+            }
+            const createParams = { userId: 'me', requestBody: { message: { raw } } };
+            if (params.threadId && createParams.requestBody?.message) {
+                createParams.requestBody.message.threadId = params.threadId;
+            }
+            const { data } = await gmail.users.drafts.create(createParams);
+            if (data.message?.payload) {
+                data.message.payload = processMessagePart(data.message.payload, params.includeBodyHtml);
+            }
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'update_draft',
+        description: 'Update an existing draft\'s content. Replaces the draft message with new content.',
+        parameters: z.object({
+            id: z.string().describe("The ID of the draft to update"),
+            raw: z.string().optional().describe("The entire email message in base64url encoded RFC 2822 format, ignores other params if provided"),
+            threadId: z.string().optional().describe("The thread ID to associate this draft with"),
+            to: z.array(z.string()).optional().describe("List of recipient email addresses"),
+            cc: z.array(z.string()).optional().describe("List of CC recipient email addresses"),
+            bcc: z.array(z.string()).optional().describe("List of BCC recipient email addresses"),
+            subject: z.string().optional().describe("The subject of the email"),
+            body: z.string().optional().describe("The body of the email"),
+            attachments: z.array(z.object({
+                filename: z.string().describe("Attachment file name"),
+                mimeType: z.string().describe("MIME type of the attachment"),
+                base64Data: z.string().describe("Base64 encoded attachment data"),
+            })).optional().describe("File attachments to include"),
+            includeBodyHtml: z.boolean().optional().describe("Whether to include the parsed HTML in the return for each body"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            let raw = params.raw;
+            if (!raw) {
+                if (params.attachments?.length) {
+                    raw = await constructRawMessageWithAttachments(gmail, params);
+                } else {
+                    raw = await constructRawMessage(gmail, params);
+                }
+            }
+            const updateParams = { userId: 'me', id: params.id, requestBody: { message: { raw } } };
+            if (params.threadId && updateParams.requestBody?.message) {
+                updateParams.requestBody.message.threadId = params.threadId;
+            }
+            const { data } = await gmail.users.drafts.update(updateParams);
+            if (data.message?.payload) {
+                data.message.payload = processMessagePart(data.message.payload, params.includeBodyHtml);
+            }
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'delete_draft',
+        description: 'Delete a draft',
+        parameters: z.object({
+            id: z.string().describe("The ID of the draft to delete"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.drafts.delete({ userId: 'me', id: params.id });
+            return JSON.stringify(data || { success: true });
+        },
+    });
+
+    server.addTool({
+        name: 'get_draft',
+        description: 'Get a specific draft by ID',
+        parameters: z.object({
+            id: z.string().describe("The ID of the draft to retrieve"),
+            includeBodyHtml: z.boolean().optional().describe("Whether to include the parsed HTML in the return for each body"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.drafts.get({ userId: 'me', id: params.id, format: 'full' });
+            if (data.message?.payload) {
+                data.message.payload = processMessagePart(data.message.payload, params.includeBodyHtml);
+            }
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'list_drafts',
+        description: 'List drafts in the user\'s mailbox',
+        parameters: z.object({
+            maxResults: z.number().optional().describe("Maximum number of drafts to return (1-500)"),
+            q: z.string().optional().describe("Only return drafts matching the specified query"),
+            includeSpamTrash: z.boolean().optional().describe("Include drafts from SPAM and TRASH"),
+            includeBodyHtml: z.boolean().optional().describe("Whether to include the parsed HTML in the return for each body"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            let drafts = [];
+            const { data } = await gmail.users.drafts.list({ userId: 'me', ...params });
+            drafts.push(...(data.drafts || []));
+            let pageToken = data.nextPageToken;
+            while (pageToken) {
+                const { data: nextData } = await gmail.users.drafts.list({ userId: 'me', ...params, pageToken });
+                drafts.push(...(nextData.drafts || []));
+                pageToken = nextData.nextPageToken;
+            }
+            drafts = drafts.map(draft => {
+                if (draft.message?.payload) {
+                    draft.message.payload = processMessagePart(draft.message.payload, params.includeBodyHtml);
+                }
+                return draft;
+            });
+            return JSON.stringify(drafts);
+        },
+    });
+
+    server.addTool({
+        name: 'send_draft',
+        description: 'Send an existing draft',
+        parameters: z.object({
+            id: z.string().describe("The ID of the draft to send"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            try {
+                const { data } = await gmail.users.drafts.send({ userId: 'me', requestBody: { id: params.id } });
+                return JSON.stringify(data);
+            } catch (error) {
+                throw new UserError('Error sending draft, are you sure you have at least one recipient?');
+            }
+        },
+    });
+}

package/dist/tools/gmail/labels.js

@@ -0,0 +1,103 @@
+// Gmail Label tools
+import { z } from 'zod';
+import { getGmailClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'create_label',
+        description: 'Create a new label',
+        parameters: z.object({
+            name: z.string().describe("The display name of the label"),
+            messageListVisibility: z.enum(['show', 'hide']).optional().describe("Visibility of messages with this label in the message list"),
+            labelListVisibility: z.enum(['labelShow', 'labelShowIfUnread', 'labelHide']).optional().describe("Visibility of the label in the label list"),
+            color: z.object({
+                textColor: z.string().describe("The text color as hex string"),
+                backgroundColor: z.string().describe("The background color as hex string"),
+            }).optional().describe("The color settings for the label"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.labels.create({ userId: 'me', requestBody: params });
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'delete_label',
+        description: 'Delete a label',
+        parameters: z.object({
+            id: z.string().describe("The ID of the label to delete"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.labels.delete({ userId: 'me', id: params.id });
+            return JSON.stringify(data || { success: true });
+        },
+    });
+
+    server.addTool({
+        name: 'get_label',
+        description: 'Get a specific label by ID',
+        parameters: z.object({
+            id: z.string().describe("The ID of the label to retrieve"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.labels.get({ userId: 'me', id: params.id });
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'list_labels',
+        description: 'List all labels in the user\'s mailbox',
+        parameters: z.object({}),
+        execute: async () => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.labels.list({ userId: 'me' });
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'patch_label',
+        description: 'Patch an existing label (partial update)',
+        parameters: z.object({
+            id: z.string().describe("The ID of the label to patch"),
+            name: z.string().optional().describe("The display name of the label"),
+            messageListVisibility: z.enum(['show', 'hide']).optional().describe("Visibility of messages with this label"),
+            labelListVisibility: z.enum(['labelShow', 'labelShowIfUnread', 'labelHide']).optional().describe("Visibility of the label in the label list"),
+            color: z.object({
+                textColor: z.string().describe("The text color as hex string"),
+                backgroundColor: z.string().describe("The background color as hex string"),
+            }).optional().describe("The color settings for the label"),
+        }),
+        execute: async (params) => {
+            const { id, ...labelData } = params;
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.labels.patch({ userId: 'me', id, requestBody: labelData });
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'update_label',
+        description: 'Update an existing label',
+        parameters: z.object({
+            id: z.string().describe("The ID of the label to update"),
+            name: z.string().optional().describe("The display name of the label"),
+            messageListVisibility: z.enum(['show', 'hide']).optional().describe("Visibility of messages with this label"),
+            labelListVisibility: z.enum(['labelShow', 'labelShowIfUnread', 'labelHide']).optional().describe("Visibility of the label in the label list"),
+            color: z.object({
+                textColor: z.string().describe("The text color as hex string"),
+                backgroundColor: z.string().describe("The background color as hex string"),
+            }).optional().describe("The color settings for the label"),
+        }),
+        execute: async (params) => {
+            const { id, ...labelData } = params;
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.labels.update({ userId: 'me', id, requestBody: labelData });
+            return JSON.stringify(data);
+        },
+    });
+}