google-tools-mcp 1.0.0 → 1.0.2

package/dist/tools/gmail/threads.js

@@ -1,145 +1,145 @@
-// Gmail Thread tools
-import { z } from 'zod';
-import { getGmailClient } from '../../clients.js';
-import { processMessagePart } from '../../helpers.js';
-
-export function register(server) {
-    server.addTool({
-        name: 'get_thread',
-        description: 'Get a specific thread by ID',
-        parameters: z.object({
-            id: z.string().describe("The ID of the thread 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.threads.get({ userId: 'me', id: params.id, format: 'full' });
-            if (data.messages) {
-                data.messages = data.messages.map(message => {
-                    if (message.payload) {
-                        message.payload = processMessagePart(message.payload, params.includeBodyHtml);
-                    }
-                    return message;
-                });
-            }
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'list_threads',
-        description: 'List threads in the user\'s mailbox',
-        parameters: z.object({
-            maxResults: z.number().optional().describe("Maximum number of threads to return"),
-            pageToken: z.string().optional().describe("Page token to retrieve a specific page of results"),
-            q: z.string().optional().describe("Only return threads matching the specified query"),
-            labelIds: z.array(z.string()).optional().describe("Only return threads with labels that match all specified label IDs"),
-            includeSpamTrash: z.boolean().optional().describe("Include threads 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();
-            const { data } = await gmail.users.threads.list({ userId: 'me', ...params });
-            if (data.threads) {
-                data.threads = data.threads.map(thread => {
-                    if (thread.messages) {
-                        thread.messages = thread.messages.map(message => {
-                            if (message.payload) {
-                                message.payload = processMessagePart(message.payload, params.includeBodyHtml);
-                            }
-                            return message;
-                        });
-                    }
-                    return thread;
-                });
-            }
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'batch_get_threads',
-        description: 'Get multiple threads by ID in parallel. More efficient than calling get_thread multiple times.',
-        parameters: z.object({
-            ids: z.array(z.string()).describe("The IDs of the threads 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 results = await Promise.all(
-                params.ids.map(async (id) => {
-                    try {
-                        const { data } = await gmail.users.threads.get({ userId: 'me', id, format: 'full' });
-                        if (data.messages) {
-                            data.messages = data.messages.map(message => {
-                                if (message.payload) {
-                                    message.payload = processMessagePart(message.payload, params.includeBodyHtml);
-                                }
-                                return message;
-                            });
-                        }
-                        return data;
-                    } catch (error) {
-                        return { id, error: error.message || 'Failed to retrieve thread' };
-                    }
-                })
-            );
-            return JSON.stringify(results);
-        },
-    });
-
-    server.addTool({
-        name: 'modify_thread',
-        description: 'Modify the labels applied to a thread',
-        parameters: z.object({
-            id: z.string().describe("The ID of the thread to modify"),
-            addLabelIds: z.array(z.string()).optional().describe("Label IDs to add"),
-            removeLabelIds: z.array(z.string()).optional().describe("Label IDs to remove"),
-        }),
-        execute: async (params) => {
-            const { id, ...threadData } = params;
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.threads.modify({ userId: 'me', id, requestBody: threadData });
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'delete_thread',
-        description: 'Delete a thread',
-        parameters: z.object({
-            id: z.string().describe("The ID of the thread to delete"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.threads.delete({ userId: 'me', id: params.id });
-            return JSON.stringify(data || { success: true });
-        },
-    });
-
-    server.addTool({
-        name: 'trash_thread',
-        description: 'Move a thread to the trash',
-        parameters: z.object({
-            id: z.string().describe("The ID of the thread to move to trash"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.threads.trash({ userId: 'me', id: params.id });
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'untrash_thread',
-        description: 'Remove a thread from the trash',
-        parameters: z.object({
-            id: z.string().describe("The ID of the thread to remove from trash"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.threads.untrash({ userId: 'me', id: params.id });
-            return JSON.stringify(data);
-        },
-    });
-}
+// Gmail Thread tools
+import { z } from 'zod';
+import { getGmailClient } from '../../clients.js';
+import { processMessagePart } from '../../helpers.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'get_thread',
+        description: 'Get a specific thread by ID',
+        parameters: z.object({
+            id: z.string().describe("The ID of the thread 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.threads.get({ userId: 'me', id: params.id, format: 'full' });
+            if (data.messages) {
+                data.messages = data.messages.map(message => {
+                    if (message.payload) {
+                        message.payload = processMessagePart(message.payload, params.includeBodyHtml);
+                    }
+                    return message;
+                });
+            }
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'list_threads',
+        description: 'List threads in the user\'s mailbox',
+        parameters: z.object({
+            maxResults: z.number().optional().describe("Maximum number of threads to return"),
+            pageToken: z.string().optional().describe("Page token to retrieve a specific page of results"),
+            q: z.string().optional().describe("Only return threads matching the specified query"),
+            labelIds: z.array(z.string()).optional().describe("Only return threads with labels that match all specified label IDs"),
+            includeSpamTrash: z.boolean().optional().describe("Include threads 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();
+            const { data } = await gmail.users.threads.list({ userId: 'me', ...params });
+            if (data.threads) {
+                data.threads = data.threads.map(thread => {
+                    if (thread.messages) {
+                        thread.messages = thread.messages.map(message => {
+                            if (message.payload) {
+                                message.payload = processMessagePart(message.payload, params.includeBodyHtml);
+                            }
+                            return message;
+                        });
+                    }
+                    return thread;
+                });
+            }
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'batch_get_threads',
+        description: 'Get multiple threads by ID in parallel. More efficient than calling get_thread multiple times.',
+        parameters: z.object({
+            ids: z.array(z.string()).describe("The IDs of the threads 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 results = await Promise.all(
+                params.ids.map(async (id) => {
+                    try {
+                        const { data } = await gmail.users.threads.get({ userId: 'me', id, format: 'full' });
+                        if (data.messages) {
+                            data.messages = data.messages.map(message => {
+                                if (message.payload) {
+                                    message.payload = processMessagePart(message.payload, params.includeBodyHtml);
+                                }
+                                return message;
+                            });
+                        }
+                        return data;
+                    } catch (error) {
+                        return { id, error: error.message || 'Failed to retrieve thread' };
+                    }
+                })
+            );
+            return JSON.stringify(results);
+        },
+    });
+
+    server.addTool({
+        name: 'modify_thread',
+        description: 'Modify the labels applied to a thread',
+        parameters: z.object({
+            id: z.string().describe("The ID of the thread to modify"),
+            addLabelIds: z.array(z.string()).optional().describe("Label IDs to add"),
+            removeLabelIds: z.array(z.string()).optional().describe("Label IDs to remove"),
+        }),
+        execute: async (params) => {
+            const { id, ...threadData } = params;
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.threads.modify({ userId: 'me', id, requestBody: threadData });
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'delete_thread',
+        description: 'Delete a thread',
+        parameters: z.object({
+            id: z.string().describe("The ID of the thread to delete"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.threads.delete({ userId: 'me', id: params.id });
+            return JSON.stringify(data || { success: true });
+        },
+    });
+
+    server.addTool({
+        name: 'trash_thread',
+        description: 'Move a thread to the trash',
+        parameters: z.object({
+            id: z.string().describe("The ID of the thread to move to trash"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.threads.trash({ userId: 'me', id: params.id });
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'untrash_thread',
+        description: 'Remove a thread from the trash',
+        parameters: z.object({
+            id: z.string().describe("The ID of the thread to remove from trash"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.threads.untrash({ userId: 'me', id: params.id });
+            return JSON.stringify(data);
+        },
+    });
+}

package/dist/tools/index.js

@@ -1,8 +1,6 @@
-// Tool discovery and lazy-loading registration.
-//
-// Only the `load_google_tools` discovery tool is registered at startup.
-// When a category is loaded, its tools are dynamically registered and the
-// client is notified via tools/list_changed so it picks them up.
+// Tool registration — all categories loaded eagerly at startup.
+// (Claude Code doesn't support notifications/tools/list_changed,
+//  so lazy-loading doesn't work.)
 import { z } from 'zod';
 import * as fs from 'fs/promises';
 import { getTokenPath } from '../auth.js';
@@ -10,11 +8,8 @@ import { resetClients } from '../clients.js';
 import { logger } from '../logger.js';
 
 // --- Category registry ---
-// Maps category names to { loader, description, toolCount }
 const CATEGORIES = {
     files: {
-        description: 'Google Drive file management — list, search, create, copy, move, rename, delete files/folders, read file contents (pdf, docx), search within files',
-        toolCount: 16,
         async loader(server) {
             const { registerDriveTools } = await import('./drive/index.js');
             const { registerExtrasTools } = await import('./extras/index.js');
@@ -23,8 +18,6 @@ const CATEGORIES = {
         },
     },
     documents: {
-        description: 'Google Docs — read, write, insert text/tables/images, formatting, comments, tabs, markdown conversion',
-        toolCount: 23,
         async loader(server) {
             const { registerDocsTools } = await import('./docs/index.js');
             const { registerUtilsTools } = await import('./utils/index.js');
@@ -33,16 +26,12 @@ const CATEGORIES = {
         },
     },
     spreadsheets: {
-        description: 'Google Sheets — read, write, format cells, charts, tables, conditional formatting, data validation',
-        toolCount: 30,
         async loader(server) {
             const { registerSheetsTools } = await import('./sheets/index.js');
             registerSheetsTools(server);
         },
     },
     email: {
-        description: 'Gmail — send, reply, forward, get, list, delete, trash messages, create/update/send drafts, attachments, batch operations',
-        toolCount: 19,
         async loader(server) {
             const { register: registerMessages } = await import('./gmail/messages.js');
             const { register: registerDrafts } = await import('./gmail/drafts.js');
@@ -51,94 +40,40 @@ const CATEGORIES = {
         },
     },
     email_threads: {
-        description: 'Gmail threads — get, list, batch get, modify, delete, trash/untrash conversation threads',
-        toolCount: 7,
         async loader(server) {
             const { register } = await import('./gmail/threads.js');
             register(server);
         },
     },
     email_labels: {
-        description: 'Gmail labels — create, delete, get, list, update labels for organizing email',
-        toolCount: 6,
         async loader(server) {
             const { register } = await import('./gmail/labels.js');
             register(server);
         },
     },
     email_settings: {
-        description: 'Gmail settings — auto-forwarding, IMAP, POP, vacation responder, delegates, filters, forwarding addresses, send-as aliases, S/MIME, profile, mailbox watch',
-        toolCount: 37,
         async loader(server) {
             const { register } = await import('./gmail/settings.js');
             register(server);
         },
     },
+    calendar: {
+        async loader(server) {
+            const { registerCalendarTools } = await import('./calendar/index.js');
+            registerCalendarTools(server);
+        },
+    },
 };
 
-// Track which categories have been loaded
-const loadedCategories = new Set();
-
 // ---------------------------------------------------------------------------
-// Notify the MCP client that the tool list has changed
+// Public: register all tools eagerly, plus the logout utility.
 // ---------------------------------------------------------------------------
-function notifyToolsChanged(server) {
-    try {
-        const session = server.sessions?.[0];
-        if (session?.server?.notification) {
-            session.server.notification({ method: 'notifications/tools/list_changed' });
-            logger.debug('Sent tools/list_changed notification.');
-        } else {
-            logger.debug('No session available for tools/list_changed notification.');
-        }
-    } catch (err) {
-        logger.warn('Failed to send tools/list_changed notification:', err.message);
+export async function registerAllTools(server) {
+    // Load every category
+    for (const [name, { loader }] of Object.entries(CATEGORIES)) {
+        await loader(server);
     }
-}
-
-// ---------------------------------------------------------------------------
-// Public: register the discovery tool (and logout)
-// ---------------------------------------------------------------------------
-export function registerAllTools(server) {
-    // --- Discovery tool ---
-    server.addTool({
-        name: 'load_google_tools',
-        description:
-            'Load Google Workspace tools by category. Call this first before using any Google service.\n\n' +
-            'Categories:\n' +
-            Object.entries(CATEGORIES)
-                .map(([name, { description, toolCount }]) => `  • ${name} (${toolCount} tools) — ${description}`)
-                .join('\n') +
-            '\n\nYou can load multiple categories at once by passing an array.',
-        parameters: z.object({
-            categories: z
-                .array(z.enum(Object.keys(CATEGORIES)))
-                .describe('One or more category names to load'),
-        }),
-        execute: async ({ categories }, { log }) => {
-            const results = [];
-            for (const cat of categories) {
-                if (loadedCategories.has(cat)) {
-                    results.push({ category: cat, status: 'already_loaded' });
-                    continue;
-                }
-                log.info(`Loading category: ${cat}`);
-                await CATEGORIES[cat].loader(server);
-                loadedCategories.add(cat);
-                results.push({
-                    category: cat,
-                    status: 'loaded',
-                    toolCount: CATEGORIES[cat].toolCount,
-                });
-            }
-            notifyToolsChanged(server);
-            return JSON.stringify({
-                loaded: results,
-                message: 'Tools are now available. You can call them directly.',
-                all_loaded_categories: [...loadedCategories],
-            });
-        },
-    });
+    logger.info(`Loaded all ${Object.keys(CATEGORIES).length} categories at startup.`);
 
     // --- Logout tool (always available) ---
     server.addTool({

package/dist/tools/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);
+        },
+    });
+}