@pablosr/mcp-google-calendar 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Pablo Suarez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,309 @@
+# mcp-google-calendar
+
+
+A Google Calendar (MCP) server to expose calendar operations as tools for LLM.
+
+
+## Table of Contents
+
+- [mcp-google-calendar](#mcp-google-calendar)
+  - [Table of Contents](#table-of-contents)
+  - [Important: Authentication Architecture](#important-authentication-architecture)
+    - [Current Implementation](#current-implementation)
+    - [Multi-User Scenarios](#multi-user-scenarios)
+  - [Setup](#setup)
+    - [Prerequisites](#prerequisites)
+    - [Step-by-step Configuration](#step-by-step-configuration)
+      - [1. Configure Google Cloud Console Project](#1-configure-google-cloud-console-project)
+      - [2. Create OAuth 2.0 Credentials](#2-create-oauth-20-credentials)
+      - [3. Configure the .env file](#3-configure-the-env-file)
+      - [4. Get the refresh token](#4-get-the-refresh-token)
+      - [5. Test the configuration](#5-test-the-configuration)
+    - [MCP Client Configuration](#mcp-client-configuration)
+  - [Usage](#usage)
+  - [Testing with MCP Inspector](#testing-with-mcp-inspector)
+  - [Security](#security)
+  - [Additional Resources](#additional-resources)
+  - [Available Tools](#available-tools)
+    - [google-create-event](#google-create-event)
+    - [google-update-event](#google-update-event)
+    - [google-list-events](#google-list-events)
+    - [google-search-events](#google-search-events)
+    - [google-delete-event](#google-delete-event)
+    - [google-list-calendars](#google-list-calendars)
+    - [google-get-current-datetime](#google-get-current-datetime)
+  - [License](#license)
+
+
+## Important: Authentication Architecture
+
+**This MCP server is configured to use a single Google account for all operations.** The authentication credentials (client ID, client secret, and refresh token) are stored in environment variables (`.env` file), meaning all users of this MCP server will interact with the same Google Calendar account.
+
+### Current Implementation
+- **Single Account Mode**: One Google account's credentials are configured in the `.env` file
+- **All operations** (create, read, update, delete events) are performed on this single account
+- **Best for**: Personal use, single-user applications, or shared team calendars
+
+### Multi-User Scenarios
+If you need **each user to authenticate with their own Google account**, this server would require modifications:
+
+1. **Add user authentication layer**: Implement a user authentication system (OAuth2, sessions, JWT, etc.)
+2. **Pass user context**: Modify the MCP tools to use the authenticated user's token instead of the `.env` token
+3. **Token refresh logic**: Implement per-user token refresh and management
+
+> **Note**: The current implementation prioritizes simplicity for personal use.
+
+
+## Setup
+
+### Prerequisites
+
+1. A Google account
+2. Access to Google Cloud Console
+3. Node.js installed
+
+### Step-by-step Configuration
+
+#### 1. Configure Google Cloud Console Project
+
+1. Go to [Google Cloud Console](https://console.cloud.google.com/)
+2. Create a new project or select an existing one
+3. Enable the [**Google Calendar API**](https://console.cloud.google.com/apis/library/calendar-json.googleapis.com):
+   - Go to "APIs & Services" > "Library"
+   - Search for "Google Calendar API"
+   - Click "Enable"
+
+#### 2. Create OAuth 2.0 Credentials
+
+1. Go to "APIs & Services" > "Credentials"
+2. Click "Create Credentials" > "OAuth 2.0 Client ID"
+3. If it's your first time, configure the OAuth consent screen:
+   - Select "External" (or "Internal" if you have Google Workspace)
+   - Complete the basic app information
+   - In "Scopes", don't add any scope (we'll do this programmatically)
+   - Add your email as a test user
+4. Create the OAuth 2.0 Client ID:
+   - Application type: "Web application"
+   - Name: "Google Calendar MCP Server"
+   - Authorized redirect URIs: `http://localhost:8080/oauth/callback`
+
+#### 3. Configure the .env file
+
+1. Copy the credentials from Google Cloud Console
+2. Create a `.env` file in the project root:
+
+```bash
+# Google Cloud Console credentials
+GOOGLE_CLIENT_ID=your_client_id_here.apps.googleusercontent.com
+GOOGLE_CLIENT_SECRET=your_client_secret_here
+GOOGLE_REDIRECT_URL=http://localhost:8080/oauth/callback
+
+# This will be generated in the next step
+GOOGLE_REFRESH_TOKEN=
+```
+
+#### 4. Get the refresh token
+
+Run the setup script:
+
+```bash
+npm run setup:google
+```
+
+This script will:
+1. Start a temporary server on port 8080
+2. Show you a URL to authorize the application
+3. Open that URL in your browser
+4. After authorizing, give you a `refresh_token`
+5. Return token `GOOGLE_REFRESH_TOKEN`
+
+#### 5. Test the configuration
+
+```bash
+npm run build
+node dist/index.js
+```
+
+If everything is configured correctly, you'll see:
+```
+✅ Google Calendar configured correctly
+```
+
+### MCP Client Configuration
+
+Add this to your MCP client configuration (e.g., Claude Desktop config):
+
+```json
+{
+  "mcpServers": {
+    "google-calendar": {
+      "command": "npx",
+      //WIP: "args": ["mcp-google-calendar"],
+      "env": {
+        "GOOGLE_CLIENT_ID": "<your-client-id>",
+        "GOOGLE_CLIENT_SECRET": "<your-client-secret>",
+        "GOOGLE_REDIRECT_URL": "http://localhost:8080/oauth/callback",
+        "GOOGLE_REFRESH_TOKEN": "<your-refresh-token>"
+      }
+    }
+  }
+}
+```
+
+## Usage
+
+1. Compile TypeScript to JavaScript:
+```bash
+npm run build
+```
+
+2. Run the MCP server:
+```bash
+node dist/index.js
+```
+
+## Testing with MCP Inspector
+
+You can test and debug this MCP server using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector):
+
+1. Make sure you have built the project:
+```bash
+npm run build
+```
+
+2. Set up your environment variables in `.env` file:
+```bash
+GOOGLE_CLIENT_ID=your-client-id
+GOOGLE_CLIENT_SECRET=your-client-secret
+GOOGLE_REDIRECT_URL=http://localhost:8080/oauth/callback
+GOOGLE_REFRESH_TOKEN=your-refresh-token
+```
+
+3. Update `mcp-inspector-config.json` with your project path:
+```json
+{
+  "mcpServers": {
+    "mcp-google-calendar": {
+      "command": "node",
+      "args": ["dist/index.js"],
+      "env": {
+        "GOOGLE_CLIENT_ID": "${GOOGLE_CLIENT_ID}",
+        "GOOGLE_CLIENT_SECRET": "${GOOGLE_CLIENT_SECRET}",
+        "GOOGLE_REDIRECT_URL": "${GOOGLE_REDIRECT_URL}",
+        "GOOGLE_REFRESH_TOKEN": "${GOOGLE_REFRESH_TOKEN}"
+      }
+    }
+  }
+}
+```
+
+4. Run the MCP Inspector:
+```bash
+npx @modelcontextprotocol/inspector --config mcp-inspector-config.json
+```
+
+1. Open your browser to the URL shown in the terminal (default should be http://localhost:6277) to interact with the MCP server through the Inspector UI.
+
+
+## Security
+
+- **Never** share your `client_secret` or `refresh_token`
+- Add `.env` to your `.gitignore` (already included)
+- Tokens have limited permissions only for Google Calendar
+
+## Additional Resources
+
+- [Google Calendar API Documentation](https://developers.google.com/calendar/api)
+- [OAuth 2.0 for Web Server Applications](https://developers.google.com/identity/protocols/oauth2/web-server)
+- [Google Cloud Console](https://console.cloud.google.com/)
+- [Model Context Protocol Documentation](https://modelcontextprotocol.io)
+
+## Available Tools
+
+### google-create-event
+
+Creates a new calendar event in Google Calendar.
+
+Parameters:
+- `title`: String - Event title/summary
+- `start`: DateTime string - Event start time (ISO 8601 format)
+- `end`: DateTime string - Event end time (ISO 8601 format)
+- `description`: String (optional) - Event description
+- `location`: String (optional) - Event location
+- `calendarId`: String (optional) - Calendar ID (defaults to 'primary')
+
+Returns:
+- The unique ID and details of the created event
+
+### google-update-event
+
+Updates an existing event in Google Calendar.
+
+Parameters:
+- `eventId`: String - The unique ID of the event to update
+- `title`: String (optional) - New event title/summary
+- `start`: DateTime string (optional) - New event start time (ISO 8601 format)
+- `end`: DateTime string (optional) - New event end time (ISO 8601 format)
+- `description`: String (optional) - New event description
+- `location`: String (optional) - New event location
+- `calendarId`: String (optional) - Calendar ID (defaults to 'primary')
+
+Returns:
+- The updated event details
+
+### google-list-events
+
+Lists events within a specified timeframe from Google Calendar.
+
+Parameters:
+- `timeMin`: DateTime string (optional) - Start of the timeframe (ISO 8601 format)
+- `timeMax`: DateTime string (optional) - End of the timeframe (ISO 8601 format)
+- `calendarId`: String (optional) - Calendar ID (defaults to 'primary')
+- `maxResults`: Number (optional) - Maximum number of events to return (default: 10)
+
+Returns:
+- A list of events that fall within the given timeframe
+
+### google-search-events
+
+Searches for events in Google Calendar by text query.
+
+Parameters:
+- `query`: String - Search query
+- `calendarId`: String (optional) - Calendar ID (defaults to 'primary')
+- `maxResults`: Number (optional) - Maximum number of events to return (default: 10)
+
+Returns:
+- A list of events matching the search query
+
+### google-delete-event
+
+Deletes an event from Google Calendar.
+
+Parameters:
+- `eventId`: String - The unique ID of the event to delete
+- `calendarId`: String (optional) - Calendar ID (defaults to 'primary')
+
+Returns:
+- Confirmation of deletion
+
+### google-list-calendars
+
+Lists all calendars available to the user.
+
+Returns:
+- A list of calendars with their IDs and names
+
+### google-get-current-datetime
+
+Gets the current date and time in ISO 8601 format. Useful for references when creating or searching for events.
+
+Parameters:
+- `timezone`: String (optional) - Timezone in IANA format (e.g., America/New_York, Europe/Madrid). Defaults to 'Atlantic/Canary'.
+
+Returns:
+- Current date and time information including ISO 8601 format, timestamp, local time, and timezone details
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { GoogleCalendarClient } from "./tools/google-calendar.js";
+import { registerGoogleCalendarTools } from "./tools/google-calendar-mcp.js";
+const server = new McpServer({
+    name: "google-calendar-mcp",
+    version: "1.0.0",
+});
+async function main() {
+    console.error('Configurando Google Calendar API...');
+    // Verificar que las credenciales de Google estén configuradas
+    if (!process.env.GOOGLE_CLIENT_ID || !process.env.GOOGLE_CLIENT_SECRET) {
+        console.error('Error: GOOGLE_CLIENT_ID y GOOGLE_CLIENT_SECRET son requeridos');
+        process.exit(1);
+    }
+    const googleClient = new GoogleCalendarClient({
+        clientId: process.env.GOOGLE_CLIENT_ID,
+        clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+        redirectUrl: process.env.GOOGLE_REDIRECT_URL || 'http://localhost:8080/oauth/callback',
+        refreshToken: process.env.GOOGLE_REFRESH_TOKEN,
+    });
+    // Si no tenemos refresh token, mostrar URL de autorización
+    if (!process.env.GOOGLE_REFRESH_TOKEN) {
+        console.error('\n🔑 AUTORIZACIÓN REQUERIDA');
+        console.error('Visita la siguiente URL para autorizar la aplicación:');
+        console.error(googleClient.getAuthUrl());
+        console.error('\nDespués de autorizar, agrega el refresh_token al archivo .env como GOOGLE_REFRESH_TOKEN=...\n');
+        process.exit(1);
+    }
+    registerGoogleCalendarTools(googleClient, server);
+    console.log('Google Calendar configurado correctamente');
+    // Start receiving messages on stdin and sending messages on stdout
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error('Error al iniciar el servidor:', error);
+    process.exit(1);
+});

package/dist/tools/google-calendar-mcp.js

@@ -0,0 +1,16 @@
+import { registerGoogleListCalendars } from './google-list-calendars.js';
+import { registerGoogleListEvents } from './google-list-events.js';
+import { registerGoogleCreateEvent } from './google-create-event.js';
+import { registerGoogleUpdateEvent } from './google-update-event.js';
+import { registerGoogleDeleteEvent } from './google-delete-event.js';
+import { registerGoogleSearchEvents } from './google-search-events.js';
+import { registerGoogleGetCurrentDatetime } from './google-get-current-datetime.js';
+export function registerGoogleCalendarTools(googleClient, server) {
+    registerGoogleListCalendars(googleClient, server);
+    registerGoogleListEvents(googleClient, server);
+    registerGoogleCreateEvent(googleClient, server);
+    registerGoogleUpdateEvent(googleClient, server);
+    registerGoogleDeleteEvent(googleClient, server);
+    registerGoogleSearchEvents(googleClient, server);
+    registerGoogleGetCurrentDatetime(googleClient, server);
+}

package/dist/tools/google-calendar.js

@@ -0,0 +1,153 @@
+import { google } from 'googleapis';
+export class GoogleCalendarClient {
+    auth;
+    calendar;
+    constructor(config) {
+        this.auth = new google.auth.OAuth2(config.clientId, config.clientSecret, config.redirectUrl);
+        if (config.refreshToken) {
+            this.auth.setCredentials({
+                refresh_token: config.refreshToken,
+            });
+        }
+        this.calendar = google.calendar({ version: 'v3', auth: this.auth });
+    }
+    /**
+     * Genera URL de autorización para obtener el token inicial
+     */
+    getAuthUrl() {
+        const scopes = [
+            'https://www.googleapis.com/auth/calendar',
+            'https://www.googleapis.com/auth/calendar.events'
+        ];
+        return this.auth.generateAuthUrl({
+            access_type: 'offline',
+            scope: scopes,
+        });
+    }
+    /**
+     * Intercambia el código de autorización por tokens
+     */
+    async getTokens(code) {
+        const { tokens } = await this.auth.getToken(code);
+        this.auth.setCredentials(tokens);
+        return tokens;
+    }
+    /**
+     * Lista todos los calendarios del usuario
+     */
+    async listCalendars() {
+        try {
+            const response = await this.calendar.calendarList.list();
+            return response.data.items || [];
+        }
+        catch (error) {
+            console.error('Error al listar calendarios:', error);
+            throw error;
+        }
+    }
+    /**
+     * Lista eventos de un calendario específico
+     */
+    async listEvents(calendarId = 'primary', timeMin, timeMax, maxResults = 10) {
+        try {
+            const response = await this.calendar.events.list({
+                calendarId,
+                timeMin: timeMin || new Date().toISOString(),
+                timeMax,
+                maxResults,
+                singleEvents: true,
+                orderBy: 'startTime',
+            });
+            return response.data.items || [];
+        }
+        catch (error) {
+            console.error('Error al listar eventos:', error);
+            throw error;
+        }
+    }
+    /**
+     * Crea un nuevo evento
+     */
+    async createEvent(calendarId = 'primary', event) {
+        try {
+            const response = await this.calendar.events.insert({
+                calendarId,
+                requestBody: event,
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error('Error al crear evento:', error);
+            throw error;
+        }
+    }
+    /**
+     * Actualiza un evento existente
+     */
+    async updateEvent(calendarId = 'primary', eventId, event) {
+        try {
+            const response = await this.calendar.events.update({
+                calendarId,
+                eventId,
+                requestBody: event,
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error('Error al actualizar evento:', error);
+            throw error;
+        }
+    }
+    /**
+     * Elimina un evento
+     */
+    async deleteEvent(calendarId = 'primary', eventId) {
+        try {
+            await this.calendar.events.delete({
+                calendarId,
+                eventId,
+            });
+        }
+        catch (error) {
+            console.error('Error al eliminar evento:', error);
+            throw error;
+        }
+    }
+    /**
+     * Busca eventos por texto
+     */
+    async searchEvents(calendarId = 'primary', query, maxResults = 10) {
+        try {
+            const response = await this.calendar.events.list({
+                calendarId,
+                q: query,
+                maxResults,
+                singleEvents: true,
+                orderBy: 'startTime',
+            });
+            return response.data.items || [];
+        }
+        catch (error) {
+            console.error('Error al buscar eventos:', error);
+            throw error;
+        }
+    }
+}
+/**
+ * Función helper para crear eventos con formato simplificado
+ */
+export function createSimpleEvent(title, start, end, description, location) {
+    return {
+        summary: title,
+        description,
+        location,
+        start: {
+            dateTime: start,
+            timeZone: 'America/Mexico_City', // Ajusta según tu zona horaria
+        },
+        end: {
+            dateTime: end,
+            timeZone: 'America/Mexico_City',
+        },
+    };
+}

package/dist/tools/google-create-event.js

@@ -0,0 +1,49 @@
+import { createSimpleEvent } from './google-calendar.js';
+import { z } from 'zod';
+export function registerGoogleCreateEvent(googleClient, server) {
+    server.tool('google_create_event', 'Crea un nuevo evento en Google Calendar', {
+        calendarId: z.string().optional().describe('ID del calendario (por defecto: primary)'),
+        title: z.string().describe('Título del evento'),
+        start: z.string().describe('Fecha/hora de inicio en formato ISO (ej: 2023-12-01T10:00:00Z)'),
+        end: z.string().describe('Fecha/hora de fin en formato ISO'),
+        description: z.string().optional().describe('Descripción del evento (opcional)'),
+        location: z.string().optional().describe('Ubicación del evento (opcional)'),
+    }, async (args) => {
+        try {
+            const { calendarId = 'primary', title, start, end, description, location, } = args;
+            if (!title || !start || !end) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Error: title, start y end son requeridos',
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const event = createSimpleEvent(title, start, end, description, location);
+            const createdEvent = await googleClient.createEvent(calendarId, event);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Evento creado exitosamente:\nID: ${createdEvent.id}\nTítulo: ${createdEvent.summary}\nInicio: ${createdEvent.start?.dateTime}\nFin: ${createdEvent.end?.dateTime}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Error desconocido';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error al crear evento: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/google-delete-event.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export function registerGoogleDeleteEvent(googleClient, server) {
+    server.tool('google_delete_event', 'Elimina un evento de Google Calendar', {
+        calendarId: z.string().optional().describe('ID del calendario (por defecto: primary)'),
+        eventId: z.string().describe('ID del evento a eliminar'),
+    }, async (args) => {
+        try {
+            const { calendarId = 'primary', eventId } = args;
+            if (!eventId) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Error: eventId es requerido',
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            await googleClient.deleteEvent(calendarId, eventId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Evento ${eventId} eliminado exitosamente`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Error desconocido';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error al eliminar evento: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/google-get-current-datetime.js

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+export function registerGoogleGetCurrentDatetime(googleClient, server) {
+    server.tool('google_get_current_datetime', 'Obtiene la fecha y hora actual en formato ISO 8601. Útil para referencias temporales al crear o buscar eventos.', {
+        timezone: z.string().optional().describe('Zona horaria en formato IANA (ej: America/New_York, Europe/Madrid). Por defecto usa Atlantic/Canary.'),
+    }, async (args) => {
+        try {
+            const { timezone = 'Atlantic/Canary' } = args;
+            const now = new Date();
+            // Información básica
+            const isoString = now.toISOString();
+            const timestamp = now.getTime();
+            // Si se proporciona una zona horaria, formatear en esa zona
+            let localTime;
+            let formattedTime;
+            try {
+                localTime = now.toLocaleString('es-ES', {
+                    timeZone: timezone,
+                    year: 'numeric',
+                    month: '2-digit',
+                    day: '2-digit',
+                    hour: '2-digit',
+                    minute: '2-digit',
+                    second: '2-digit',
+                    hour12: false,
+                });
+                formattedTime = now.toLocaleString('es-ES', {
+                    timeZone: timezone,
+                    weekday: 'long',
+                    year: 'numeric',
+                    month: 'long',
+                    day: 'numeric',
+                    hour: '2-digit',
+                    minute: '2-digit',
+                    second: '2-digit',
+                    hour12: false,
+                });
+            }
+            catch {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error: Zona horaria inválida '${timezone}'. Usa formato IANA (ej: America/New_York, Europe/Madrid, Atlantic/Canary)`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const result = {
+                iso8601: isoString,
+                timestamp: timestamp,
+                timezone: timezone,
+                localTime: localTime,
+                formatted: formattedTime,
+                unix: Math.floor(timestamp / 1000),
+                date: {
+                    year: now.getUTCFullYear(),
+                    month: now.getUTCMonth() + 1,
+                    day: now.getUTCDate(),
+                },
+                time: {
+                    hour: now.getUTCHours(),
+                    minute: now.getUTCMinutes(),
+                    second: now.getUTCSeconds(),
+                },
+            };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error al obtener la fecha y hora actual: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/google-list-calendars.js

@@ -0,0 +1,34 @@
+export function registerGoogleListCalendars(googleClient, server) {
+    server.tool('google_list_calendars', 'Lista todos los calendarios disponibles en Google Calendar', async () => {
+        try {
+            const calendars = await googleClient.listCalendars();
+            const data = calendars.map((cal) => ({
+                id: cal.id,
+                summary: cal.summary,
+                description: cal.description,
+                timeZone: cal.timeZone,
+                accessRole: cal.accessRole,
+            }));
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(data, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Error desconocido';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error al listar calendarios: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/google-list-events.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export function registerGoogleListEvents(googleClient, server) {
+    server.tool('google_list_events', 'Lista eventos de un calendario de Google Calendar', {
+        calendarId: z.string().optional().describe('ID del calendario (por defecto: primary)'),
+        timeMin: z.string().optional().describe('Fecha/hora mínima en formato ISO (ej: 2023-12-01T00:00:00Z)'),
+        timeMax: z.string().optional().describe('Fecha/hora máxima en formato ISO'),
+        maxResults: z.number().optional().describe('Número máximo de resultados (por defecto: 10)'),
+    }, async (args) => {
+        try {
+            const { calendarId = 'primary', timeMin, timeMax, maxResults = 10, } = args;
+            const events = await googleClient.listEvents(calendarId, timeMin, timeMax, maxResults);
+            const data = events.map((event) => ({
+                id: event.id,
+                summary: event.summary,
+                description: event.description,
+                location: event.location,
+                start: event.start,
+                end: event.end,
+                status: event.status,
+            }));
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(data, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Error desconocido';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error al listar eventos: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/google-search-events.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+export function registerGoogleSearchEvents(googleClient, server) {
+    server.tool('google_search_events', 'Busca eventos en Google Calendar por texto', {
+        calendarId: z.string().optional().describe('ID del calendario (por defecto: primary)'),
+        query: z.string().describe('Texto a buscar en los eventos'),
+        maxResults: z.number().optional().describe('Número máximo de resultados (por defecto: 10)'),
+    }, async (args) => {
+        try {
+            const { calendarId = 'primary', query, maxResults = 10, } = args;
+            if (!query) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Error: query es requerido',
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const events = await googleClient.searchEvents(calendarId, query, maxResults);
+            const data = events.map((event) => ({
+                id: event.id,
+                summary: event.summary,
+                description: event.description,
+                location: event.location,
+                start: event.start,
+                end: event.end,
+            }));
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(data, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Error desconocido';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error al buscar eventos: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/google-update-event.js

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+export function registerGoogleUpdateEvent(googleClient, server) {
+    server.tool('google_update_event', 'Actualiza un evento existente en Google Calendar', {
+        calendarId: z.string().optional().describe('ID del calendario (por defecto: primary)'),
+        eventId: z.string().describe('ID del evento a actualizar'),
+        title: z.string().optional().describe('Nuevo título del evento'),
+        start: z.string().optional().describe('Nueva fecha/hora de inicio en formato ISO (ej: 2023-12-01T10:00:00Z)'),
+        end: z.string().optional().describe('Nueva fecha/hora de fin en formato ISO'),
+        description: z.string().optional().describe('Nueva descripción del evento'),
+        location: z.string().optional().describe('Nueva ubicación del evento'),
+    }, async (args) => {
+        try {
+            const { calendarId = 'primary', eventId, title, start, end, description, location, } = args;
+            if (!eventId) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Error: eventId es requerido',
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            // Construir el objeto de evento con solo los campos proporcionados
+            const event = {};
+            if (title !== undefined) {
+                event.summary = title;
+            }
+            if (description !== undefined) {
+                event.description = description;
+            }
+            if (location !== undefined) {
+                event.location = location;
+            }
+            if (start !== undefined) {
+                event.start = {
+                    dateTime: start,
+                    timeZone: 'America/Mexico_City',
+                };
+            }
+            if (end !== undefined) {
+                event.end = {
+                    dateTime: end,
+                    timeZone: 'America/Mexico_City',
+                };
+            }
+            const updatedEvent = await googleClient.updateEvent(calendarId, eventId, event);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Evento actualizado exitosamente:\nID: ${updatedEvent.id}\nTítulo: ${updatedEvent.summary}\nInicio: ${updatedEvent.start?.dateTime}\nFin: ${updatedEvent.end?.dateTime}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Error desconocido';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error al actualizar evento: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@pablosr/mcp-google-calendar",
+  "description": "A Google Calendar (MCP) server to expose calendar operations as tools for LLM.",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "mcp-google-calendar": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && shx chmod +x dist/*.js",
+    "watch": "tsc --watch",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "format": "prettier --write src/.",
+    "format:check": "prettier --check src/.",
+    "setup:google": "node scripts/setup-google-oauth.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PabloSR06/mcp-google-calendar.git"
+  },
+  "bugs": {
+    "url": "https://github.com/PabloSR06/mcp-google-calendar/issues"
+  },
+  "homepage": "https://github.com/PabloSR06/mcp-google-calendar#readme",
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@google-cloud/local-auth": "^3.0.1",
+    "@modelcontextprotocol/sdk": "^1.13.0",
+    "dotenv": "^16.5.0",
+    "googleapis": "^162.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.29.0",
+    "@types/node": "^24.0.3",
+    "eslint": "^9.29.0",
+    "eslint-config-prettier": "^10.1.5",
+    "prettier": "3.5.3",
+    "shx": "^0.4.0",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.34.1"
+  }
+}