mcp-google-multi 4.2.0

package/dist/tools/calendar.js

@@ -0,0 +1,399 @@
+import { z } from 'zod';
+import { google } from 'googleapis';
+import { ACCOUNTS } from '../accounts.js';
+import { getClient } from '../client.js';
+import { handleGoogleApiError } from './_errors.js';
+const accountEnum = z.enum(ACCOUNTS);
+export function registerCalendarTools(server) {
+    server.registerTool('calendar_list_calendars', {
+        description: 'List all calendars for a Google account',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+        },
+    }, async ({ account }) => {
+        try {
+            const auth = await getClient(account);
+            const cal = google.calendar({ version: 'v3', auth });
+            const res = await cal.calendarList.list();
+            const calendars = (res.data.items ?? []).map((c) => ({
+                id: c.id,
+                summary: c.summary,
+                description: c.description ?? '',
+                primary: c.primary ?? false,
+                timeZone: c.timeZone,
+                backgroundColor: c.backgroundColor,
+            }));
+            return {
+                content: [{ type: 'text', text: JSON.stringify(calendars, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleCalendarError(error, account);
+        }
+    });
+    server.registerTool('calendar_list_events', {
+        description: 'List events from a Google Calendar',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            calendarId: z.string().default('primary').optional()
+                .describe('Calendar ID (default: primary)'),
+            query: z.string().optional().describe('Free-text search query'),
+            timeMin: z.string().optional()
+                .describe('Start of time range (ISO 8601, e.g. "2026-04-04T00:00:00Z")'),
+            timeMax: z.string().optional()
+                .describe('End of time range (ISO 8601)'),
+            maxResults: z.number().min(1).max(250).default(25).optional()
+                .describe('Max events to return (default: 25)'),
+        },
+    }, async ({ account, calendarId, query, timeMin, timeMax, maxResults }) => {
+        try {
+            const auth = await getClient(account);
+            const cal = google.calendar({ version: 'v3', auth });
+            const params = {
+                calendarId: calendarId ?? 'primary',
+                maxResults: maxResults ?? 25,
+                singleEvents: true,
+                orderBy: 'startTime',
+            };
+            if (query)
+                params.q = query;
+            if (timeMin)
+                params.timeMin = timeMin;
+            if (timeMax)
+                params.timeMax = timeMax;
+            if (!timeMin && !timeMax) {
+                params.timeMin = new Date().toISOString();
+            }
+            const res = await cal.events.list(params);
+            const events = (res.data.items ?? []).map(formatEvent);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(events, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleCalendarError(error, account);
+        }
+    });
+    server.registerTool('calendar_get_event', {
+        description: 'Get a single Google Calendar event by ID',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            eventId: z.string().describe('Calendar event ID'),
+            calendarId: z.string().default('primary').optional()
+                .describe('Calendar ID (default: primary)'),
+        },
+    }, async ({ account, eventId, calendarId }) => {
+        try {
+            const auth = await getClient(account);
+            const cal = google.calendar({ version: 'v3', auth });
+            const res = await cal.events.get({
+                calendarId: calendarId ?? 'primary',
+                eventId,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(formatEvent(res.data), null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleCalendarError(error, account);
+        }
+    });
+    server.registerTool('calendar_create_event', {
+        description: 'Create a Google Calendar event',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            summary: z.string().describe('Event title'),
+            start: z.string().describe('Start time (ISO 8601, e.g. "2026-04-05T10:00:00+01:00")'),
+            end: z.string().describe('End time (ISO 8601)'),
+            description: z.string().optional().describe('Event description'),
+            location: z.string().optional().describe('Event location'),
+            attendees: z.string().optional()
+                .describe('Comma-separated email addresses of attendees'),
+            calendarId: z.string().default('primary').optional()
+                .describe('Calendar ID (default: primary)'),
+            allDay: z.boolean().default(false).optional()
+                .describe('If true, start/end are dates (YYYY-MM-DD) not datetimes'),
+        },
+    }, async ({ account, summary, start, end, description, location, attendees, calendarId, allDay }) => {
+        try {
+            const auth = await getClient(account);
+            const cal = google.calendar({ version: 'v3', auth });
+            const event = { summary };
+            if (allDay) {
+                event.start = { date: start };
+                event.end = { date: end };
+            }
+            else {
+                event.start = { dateTime: start };
+                event.end = { dateTime: end };
+            }
+            if (description)
+                event.description = description;
+            if (location)
+                event.location = location;
+            if (attendees) {
+                event.attendees = attendees.split(',').map((e) => ({ email: e.trim() }));
+            }
+            const res = await cal.events.insert({
+                calendarId: calendarId ?? 'primary',
+                requestBody: event,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(formatEvent(res.data), null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return handleCalendarError(error, account);
+        }
+    });
+    server.registerTool('calendar_update_event', {
+        description: 'Update a Google Calendar event',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            eventId: z.string().describe('Calendar event ID'),
+            summary: z.string().optional().describe('New event title'),
+            start: z.string().optional().describe('New start time (ISO 8601)'),
+            end: z.string().optional().describe('New end time (ISO 8601)'),
+            description: z.string().optional().describe('New event description'),
+            location: z.string().optional().describe('New event location'),
+            attendees: z.string().optional()
+                .describe('Comma-separated email addresses (replaces existing attendees)'),
+            calendarId: z.string().default('primary').optional()
+                .describe('Calendar ID (default: primary)'),
+        },
+    }, async ({ account, eventId, summary, start, end, description, location, attendees, calendarId }) => {
+        try {
+            const auth = await getClient(account);
+            const cal = google.calendar({ version: 'v3', auth });
+            // Fetch the event first so a 404 surfaces before we attempt the patch.
+            await cal.events.get({
+                calendarId: calendarId ?? 'primary',
+                eventId,
+            });
+            const patch = {};
+            if (summary !== undefined)
+                patch.summary = summary;
+            if (description !== undefined)
+                patch.description = description;
+            if (location !== undefined)
+                patch.location = location;
+            if (start !== undefined) {
+                patch.start = start.length === 10
+                    ? { date: start }
+                    : { dateTime: start };
+            }
+            if (end !== undefined) {
+                patch.end = end.length === 10
+                    ? { date: end }
+                    : { dateTime: end };
+            }
+            if (attendees !== undefined) {
+                patch.attendees = attendees.split(',').map((e) => ({ email: e.trim() }));
+            }
+            const res = await cal.events.patch({
+                calendarId: calendarId ?? 'primary',
+                eventId,
+                requestBody: patch,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(formatEvent(res.data), null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return handleCalendarError(error, account);
+        }
+    });
+    server.registerTool('calendar_delete_event', {
+        description: 'Delete a Google Calendar event',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            eventId: z.string().describe('Calendar event ID'),
+            calendarId: z.string().default('primary').optional()
+                .describe('Calendar ID (default: primary)'),
+        },
+    }, async ({ account, eventId, calendarId }) => {
+        try {
+            const auth = await getClient(account);
+            const cal = google.calendar({ version: 'v3', auth });
+            await cal.events.delete({
+                calendarId: calendarId ?? 'primary',
+                eventId,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ deleted: true, eventId }, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleCalendarError(error, account);
+        }
+    });
+    server.registerTool('calendar_quick_add', {
+        description: 'Create a calendar event from a natural language string. Google parses date, time, title, and guests automatically.',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            calendarId: z.string().default('primary').optional()
+                .describe('Calendar ID (default: primary)'),
+            text: z.string().describe('Natural language event, e.g. "Lunch with Farouk Thursday 1pm at Le Boulanger"'),
+            sendNotifications: z.boolean().optional().describe('Send notifications to attendees (default: false)'),
+        },
+    }, async ({ account, calendarId, text, sendNotifications }) => {
+        try {
+            const auth = await getClient(account);
+            const cal = google.calendar({ version: 'v3', auth });
+            const res = await cal.events.quickAdd({
+                calendarId: calendarId ?? 'primary',
+                text,
+                sendNotifications: sendNotifications ?? false,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(formatEvent(res.data), null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleCalendarError(error, account);
+        }
+    });
+    server.registerTool('calendar_move_event', {
+        description: 'Move an event from one calendar to another',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            calendarId: z.string().describe('Source calendar ID'),
+            eventId: z.string().describe('Event ID to move'),
+            destinationCalendarId: z.string().describe('Destination calendar ID'),
+            sendNotifications: z.boolean().optional().describe('Send notifications (default: false)'),
+        },
+    }, async ({ account, calendarId, eventId, destinationCalendarId, sendNotifications }) => {
+        try {
+            const auth = await getClient(account);
+            const cal = google.calendar({ version: 'v3', auth });
+            const res = await cal.events.move({
+                calendarId,
+                eventId,
+                destination: destinationCalendarId,
+                sendNotifications: sendNotifications ?? false,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(formatEvent(res.data), null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleCalendarError(error, account);
+        }
+    });
+    server.registerTool('calendar_list_instances', {
+        description: 'List all occurrences of a recurring calendar event',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            calendarId: z.string().default('primary').optional()
+                .describe('Calendar ID (default: primary)'),
+            eventId: z.string().describe('ID of the recurring event series'),
+            timeMin: z.string().optional().describe('ISO 8601 — filter instances after this time'),
+            timeMax: z.string().optional().describe('ISO 8601 — filter instances before this time'),
+            maxResults: z.number().min(1).max(250).default(25).optional()
+                .describe('Max instances to return (default: 25)'),
+        },
+    }, async ({ account, calendarId, eventId, timeMin, timeMax, maxResults }) => {
+        try {
+            const auth = await getClient(account);
+            const cal = google.calendar({ version: 'v3', auth });
+            const res = await cal.events.instances({
+                calendarId: calendarId ?? 'primary',
+                eventId,
+                timeMin,
+                timeMax,
+                maxResults: maxResults ?? 25,
+            });
+            const events = (res.data.items ?? []).map(formatEvent);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(events, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleCalendarError(error, account);
+        }
+    });
+    server.registerTool('calendar_get_freebusy', {
+        description: 'Check free/busy times for one or more calendars within a time window. Returns only busy blocks, not event details.',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            calendarIds: z.array(z.string()).describe('Calendar IDs to check, e.g. ["primary", "user@example.com"]'),
+            timeMin: z.string().describe('ISO 8601 start of window'),
+            timeMax: z.string().describe('ISO 8601 end of window'),
+            timeZone: z.string().optional().describe('Timezone (default: UTC)'),
+        },
+    }, async ({ account, calendarIds, timeMin, timeMax, timeZone }) => {
+        try {
+            const auth = await getClient(account);
+            const cal = google.calendar({ version: 'v3', auth });
+            const res = await cal.freebusy.query({
+                requestBody: {
+                    timeMin,
+                    timeMax,
+                    timeZone: timeZone ?? 'UTC',
+                    items: calendarIds.map((id) => ({ id })),
+                },
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data.calendars, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleCalendarError(error, account);
+        }
+    });
+    server.registerTool('calendar_create_calendar', {
+        description: 'Create a new calendar under the account',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            summary: z.string().describe('Calendar name'),
+            description: z.string().optional().describe('Calendar description'),
+            timeZone: z.string().optional().describe('Timezone (default: UTC)'),
+        },
+    }, async ({ account, summary, description, timeZone }) => {
+        try {
+            const auth = await getClient(account);
+            const cal = google.calendar({ version: 'v3', auth });
+            const res = await cal.calendars.insert({
+                requestBody: {
+                    summary,
+                    description,
+                    timeZone: timeZone ?? 'UTC',
+                },
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleCalendarError(error, account);
+        }
+    });
+}
+function formatEvent(event) {
+    return {
+        id: event.id,
+        summary: event.summary ?? '',
+        description: event.description ?? '',
+        location: event.location ?? '',
+        start: event.start?.dateTime ?? event.start?.date ?? '',
+        end: event.end?.dateTime ?? event.end?.date ?? '',
+        status: event.status,
+        htmlLink: event.htmlLink,
+        organizer: event.organizer?.email ?? '',
+        attendees: (event.attendees ?? []).map((a) => ({
+            email: a.email,
+            responseStatus: a.responseStatus,
+        })),
+        created: event.created,
+        updated: event.updated,
+    };
+}
+function handleCalendarError(error, account) {
+    return handleGoogleApiError(error, account);
+}

package/dist/tools/chat.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerChatTools(server: McpServer): void;

package/dist/tools/chat.js

@@ -0,0 +1,121 @@
+import { z } from 'zod';
+import { google } from 'googleapis';
+import { ACCOUNTS } from '../accounts.js';
+import { getClient } from '../client.js';
+import { handleGoogleApiError } from './_errors.js';
+const accountEnum = z.enum(ACCOUNTS);
+export function registerChatTools(server) {
+    server.registerTool('chat_spaces_list', {
+        description: 'List Google Chat spaces the user is a member of',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            pageSize: z.number().min(1).max(1000).optional(),
+            pageToken: z.string().optional(),
+            filter: z.string().optional().describe('Filter expression, e.g. "spaceType = \\"DIRECT_MESSAGE\\""'),
+        },
+    }, async ({ account, pageSize, pageToken, filter }) => {
+        try {
+            const auth = await getClient(account);
+            const chat = google.chat({ version: 'v1', auth });
+            const res = await chat.spaces.list({
+                pageSize: pageSize ?? 100,
+                pageToken,
+                filter,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleChatError(error, account);
+        }
+    });
+    server.registerTool('chat_spaces_get', {
+        description: 'Get details about a single Chat space',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            name: z.string().describe('Space resource name, format: spaces/{space}'),
+        },
+    }, async ({ account, name }) => {
+        try {
+            const auth = await getClient(account);
+            const chat = google.chat({ version: 'v1', auth });
+            const res = await chat.spaces.get({ name });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleChatError(error, account);
+        }
+    });
+    server.registerTool('chat_messages_create', {
+        description: 'Send a message into a Chat space. Supply plain text or a Card v2 in cardsV2.',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            parent: z.string().describe('Space resource name, format: spaces/{space}'),
+            text: z.string().optional().describe('Plain message text'),
+            cardsV2: z.array(z.record(z.string(), z.any())).optional().describe('Optional Card v2 payloads'),
+            threadKey: z.string().optional().describe('Thread key to group messages'),
+            messageReplyOption: z.enum(['MESSAGE_REPLY_OPTION_UNSPECIFIED', 'REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD', 'REPLY_MESSAGE_OR_FAIL']).optional(),
+        },
+    }, async ({ account, parent, text, cardsV2, threadKey, messageReplyOption }) => {
+        try {
+            if (!text && (!cardsV2 || cardsV2.length === 0)) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: 'Either text or cardsV2 must be provided' }) }], isError: true };
+            }
+            const auth = await getClient(account);
+            const chat = google.chat({ version: 'v1', auth });
+            const requestBody = {};
+            if (text)
+                requestBody.text = text;
+            if (cardsV2)
+                requestBody.cardsV2 = cardsV2;
+            if (threadKey)
+                requestBody.thread = { threadKey };
+            const res = await chat.spaces.messages.create({
+                parent,
+                messageReplyOption,
+                requestBody,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleChatError(error, account);
+        }
+    });
+    server.registerTool('chat_messages_list', {
+        description: 'List messages in a Chat space',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            parent: z.string().describe('Space resource name, format: spaces/{space}'),
+            pageSize: z.number().min(1).max(1000).optional(),
+            pageToken: z.string().optional(),
+            filter: z.string().optional().describe('Filter expression, e.g. "createTime > \\"2026-01-01T00:00:00Z\\""'),
+            orderBy: z.string().optional().describe('e.g. "createTime DESC"'),
+        },
+    }, async ({ account, parent, pageSize, pageToken, filter, orderBy }) => {
+        try {
+            const auth = await getClient(account);
+            const chat = google.chat({ version: 'v1', auth });
+            const res = await chat.spaces.messages.list({
+                parent,
+                pageSize: pageSize ?? 100,
+                pageToken,
+                filter,
+                orderBy,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleChatError(error, account);
+        }
+    });
+}
+function handleChatError(error, account) {
+    return handleGoogleApiError(error, account, "Chat tools require the optional \"chat\" scope bundle. Add GOOGLE_OPTIONAL_SCOPES=chat and re-auth.");
+}

package/dist/tools/contacts.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerContactsTools(server: McpServer): void;