google-tools-mcp 1.0.0 → 1.0.2

package/dist/tools/calendar/manageEvent.js

@@ -0,0 +1,250 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getCalendarClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'manage_event',
+        description:
+            'Create, update, or delete a calendar event. Supports attendees, Google Meet, reminders, attachments, visibility, and transparency settings.',
+        parameters: z.object({
+            action: z.enum(['create', 'update', 'delete']).describe('The operation to perform.'),
+            calendar_id: z
+                .string()
+                .optional()
+                .default('primary')
+                .describe('Calendar ID. Defaults to "primary".'),
+            event_id: z
+                .string()
+                .optional()
+                .describe('Event ID — required for update and delete.'),
+            summary: z
+                .string()
+                .optional()
+                .describe('Event title. Required for create.'),
+            start_time: z
+                .string()
+                .optional()
+                .describe('Start time in RFC3339 format (e.g. "2025-03-15T10:00:00-05:00") or date for all-day (e.g. "2025-03-15"). Required for create.'),
+            end_time: z
+                .string()
+                .optional()
+                .describe('End time in RFC3339 format or date for all-day. Required for create.'),
+            description: z.string().optional().describe('Event description/body.'),
+            location: z.string().optional().describe('Event location.'),
+            attendees: z
+                .array(z.string())
+                .optional()
+                .describe('List of attendee email addresses.'),
+            timezone: z
+                .string()
+                .optional()
+                .describe('Timezone for the event (e.g. "America/New_York"). Defaults to calendar timezone.'),
+            add_google_meet: z
+                .boolean()
+                .optional()
+                .describe('If true, adds a Google Meet conference link. If false on update, removes it.'),
+            reminders: z
+                .array(
+                    z.object({
+                        method: z.enum(['email', 'popup']).describe('Reminder method.'),
+                        minutes: z.number().describe('Minutes before the event to send reminder.'),
+                    })
+                )
+                .optional()
+                .describe('Custom reminders. Overrides calendar defaults.'),
+            transparency: z
+                .enum(['opaque', 'transparent'])
+                .optional()
+                .describe('"opaque" = busy (default), "transparent" = free/available.'),
+            visibility: z
+                .enum(['default', 'public', 'private', 'confidential'])
+                .optional()
+                .describe('Event visibility.'),
+            color_id: z
+                .string()
+                .optional()
+                .describe('Color ID for the event (1-11). Use list_calendars or Google Calendar docs for color mapping.'),
+            recurrence: z
+                .array(z.string())
+                .optional()
+                .describe('RRULE recurrence rules (e.g. ["RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR"]). Only for create.'),
+        }),
+        execute: async (args, { log }) => {
+            const calendar = await getCalendarClient();
+
+            try {
+                if (args.action === 'delete') {
+                    if (!args.event_id) throw new UserError('event_id is required for delete.');
+                    log.info(`Deleting event ${args.event_id} from ${args.calendar_id}`);
+                    await calendar.events.delete({
+                        calendarId: args.calendar_id,
+                        eventId: args.event_id,
+                    });
+                    return JSON.stringify({ success: true, message: `Event ${args.event_id} deleted.` });
+                }
+
+                if (args.action === 'create') {
+                    if (!args.summary) throw new UserError('summary is required for create.');
+                    if (!args.start_time) throw new UserError('start_time is required for create.');
+                    if (!args.end_time) throw new UserError('end_time is required for create.');
+
+                    const eventBody = buildEventBody(args);
+                    log.info(`Creating event "${args.summary}" on ${args.calendar_id}`);
+
+                    const params = {
+                        calendarId: args.calendar_id,
+                        requestBody: eventBody,
+                        conferenceDataVersion: args.add_google_meet ? 1 : 0,
+                    };
+
+                    const response = await calendar.events.insert(params);
+                    return JSON.stringify(formatResult('created', response.data), null, 2);
+                }
+
+                if (args.action === 'update') {
+                    if (!args.event_id) throw new UserError('event_id is required for update.');
+                    log.info(`Updating event ${args.event_id} on ${args.calendar_id}`);
+
+                    // Fetch existing event to preserve fields
+                    const existing = await calendar.events.get({
+                        calendarId: args.calendar_id,
+                        eventId: args.event_id,
+                    });
+
+                    const eventBody = buildUpdateBody(existing.data, args);
+
+                    const params = {
+                        calendarId: args.calendar_id,
+                        eventId: args.event_id,
+                        requestBody: eventBody,
+                        conferenceDataVersion: args.add_google_meet !== undefined ? 1 : 0,
+                    };
+
+                    const response = await calendar.events.update(params);
+                    return JSON.stringify(formatResult('updated', response.data), null, 2);
+                }
+
+                throw new UserError(`Unknown action: ${args.action}`);
+            } catch (error) {
+                if (error instanceof UserError) throw error;
+                log.error(`Error in manage_event (${args.action}): ${error.message || error}`);
+                if (error.code === 404)
+                    throw new UserError('Calendar or event not found. Check the IDs.');
+                if (error.code === 403)
+                    throw new UserError('Permission denied. You may not have edit access to this calendar.');
+                throw new UserError(`Failed to ${args.action} event: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}
+
+function buildTimeField(timeStr, timezone) {
+    // All-day events use 'date', timed events use 'dateTime'
+    if (/^\d{4}-\d{2}-\d{2}$/.test(timeStr)) {
+        return { date: timeStr };
+    }
+    const field = { dateTime: timeStr };
+    if (timezone) field.timeZone = timezone;
+    return field;
+}
+
+function buildEventBody(args) {
+    const body = {
+        summary: args.summary,
+        start: buildTimeField(args.start_time, args.timezone),
+        end: buildTimeField(args.end_time, args.timezone),
+    };
+
+    if (args.description) body.description = args.description;
+    if (args.location) body.location = args.location;
+    if (args.attendees) body.attendees = args.attendees.map((email) => ({ email }));
+    if (args.transparency) body.transparency = args.transparency;
+    if (args.visibility) body.visibility = args.visibility;
+    if (args.color_id) body.colorId = args.color_id;
+    if (args.recurrence) body.recurrence = args.recurrence;
+
+    if (args.reminders) {
+        body.reminders = {
+            useDefault: false,
+            overrides: args.reminders,
+        };
+    }
+
+    if (args.add_google_meet) {
+        body.conferenceData = {
+            createRequest: {
+                requestId: `meet-${Date.now()}`,
+                conferenceSolutionKey: { type: 'hangoutsMeet' },
+            },
+        };
+    }
+
+    return body;
+}
+
+function buildUpdateBody(existing, args) {
+    const body = { ...existing };
+
+    // Remove read-only fields
+    delete body.etag;
+    delete body.kind;
+    delete body.created;
+    delete body.updated;
+    delete body.creator;
+    delete body.organizer;
+    delete body.iCalUID;
+    delete body.sequence;
+    delete body.hangoutLink;
+
+    if (args.summary !== undefined) body.summary = args.summary;
+    if (args.description !== undefined) body.description = args.description;
+    if (args.location !== undefined) body.location = args.location;
+    if (args.transparency !== undefined) body.transparency = args.transparency;
+    if (args.visibility !== undefined) body.visibility = args.visibility;
+    if (args.color_id !== undefined) body.colorId = args.color_id;
+
+    if (args.start_time) body.start = buildTimeField(args.start_time, args.timezone);
+    if (args.end_time) body.end = buildTimeField(args.end_time, args.timezone);
+
+    if (args.attendees) body.attendees = args.attendees.map((email) => ({ email }));
+
+    if (args.reminders) {
+        body.reminders = {
+            useDefault: false,
+            overrides: args.reminders,
+        };
+    }
+
+    if (args.add_google_meet === true) {
+        body.conferenceData = {
+            createRequest: {
+                requestId: `meet-${Date.now()}`,
+                conferenceSolutionKey: { type: 'hangoutsMeet' },
+            },
+        };
+    } else if (args.add_google_meet === false) {
+        body.conferenceData = null;
+    }
+
+    return body;
+}
+
+function formatResult(action, event) {
+    const result = {
+        success: true,
+        action,
+        id: event.id,
+        summary: event.summary,
+        start: event.start?.dateTime || event.start?.date,
+        end: event.end?.dateTime || event.end?.date,
+        htmlLink: event.htmlLink,
+    };
+
+    if (event.hangoutLink) result.meetLink = event.hangoutLink;
+    if (event.attendees?.length) {
+        result.attendees = event.attendees.map((a) => a.email);
+    }
+
+    return result;
+}

package/dist/tools/calendar/moveEvent.js

@@ -0,0 +1,60 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getCalendarClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'move_event',
+        description:
+            'Moves an event from one calendar to another. The event is removed from the source calendar and added to the destination.',
+        parameters: z.object({
+            event_id: z.string().describe('The event ID to move.'),
+            source_calendar_id: z
+                .string()
+                .optional()
+                .default('primary')
+                .describe('Calendar ID the event is currently in. Defaults to "primary".'),
+            destination_calendar_id: z
+                .string()
+                .describe('Calendar ID to move the event to.'),
+        }),
+        execute: async (args, { log }) => {
+            const calendar = await getCalendarClient();
+            log.info(
+                `Moving event ${args.event_id} from ${args.source_calendar_id} to ${args.destination_calendar_id}`
+            );
+
+            try {
+                const response = await calendar.events.move({
+                    calendarId: args.source_calendar_id,
+                    eventId: args.event_id,
+                    destination: args.destination_calendar_id,
+                });
+
+                const event = response.data;
+                return JSON.stringify(
+                    {
+                        success: true,
+                        id: event.id,
+                        summary: event.summary,
+                        movedTo: args.destination_calendar_id,
+                        htmlLink: event.htmlLink,
+                    },
+                    null,
+                    2
+                );
+            } catch (error) {
+                log.error(`Error moving event: ${error.message || error}`);
+                if (error.code === 404)
+                    throw new UserError(
+                        'Event or calendar not found. Check the event_id and calendar IDs.'
+                    );
+                if (error.code === 403)
+                    throw new UserError(
+                        'Permission denied. You need edit access to both source and destination calendars.'
+                    );
+                throw new UserError(`Failed to move event: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

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