@pablosr/mcp-google-calendar 1.0.2 → 1.1.0

package/README.md

@@ -1,7 +1,7 @@
 # mcp-google-calendar
 
 
-A Google Calendar (MCP) server to expose calendar operations as tools for LLM.
+A Google Calendar and Google Tasks (MCP) server to expose calendar and task operations as tools for LLM.
 
 
 ## Table of Contents
@@ -22,27 +22,35 @@ A Google Calendar (MCP) server to expose calendar operations as tools for LLM.
     - [MCP Client Configuration](#mcp-client-configuration)
   - [Usage](#usage)
   - [Testing with MCP Inspector](#testing-with-mcp-inspector)
+  - [Timezone Configuration](#timezone-configuration)
   - [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)
+    - [Calendar Tools](#calendar-tools)
+      - [calendar-create-event](#calendar-create-event)
+      - [calendar-update-event](#calendar-update-event)
+      - [calendar-list-events](#calendar-list-events)
+      - [calendar-search-events](#calendar-search-events)
+      - [calendar-delete-event](#calendar-delete-event)
+      - [calendar-list-calendars](#calendar-list-calendars)
+      - [calendar-get-current-datetime](#calendar-get-current-datetime)
+    - [Tasks Tools](#tasks-tools)
+      - [tasks-list-task-lists](#tasks-list-task-lists)
+      - [tasks-list-tasks](#tasks-list-tasks)
+      - [tasks-create-task](#tasks-create-task)
+      - [tasks-update-task](#tasks-update-task)
+      - [tasks-delete-task](#tasks-delete-task)
   - [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.
+**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 and Google Tasks 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
+- **All operations** (create, read, update, delete events and tasks) are performed on this single account
+- **Best for**: Personal use, single-user applications, or shared team calendars and task lists
 
 ### Multi-User Scenarios
 If you need **each user to authenticate with their own Google account**, this server would require modifications:
@@ -68,10 +76,9 @@ If you need **each user to authenticate with their own Google account**, this se
 
 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"
+3. Enable the required APIs:
+   - **Google Calendar API**: Go to "APIs & Services" > "Library", search for "Google Calendar API" and click "Enable"
+   - **Google Tasks API**: Go to "APIs & Services" > "Library", search for "Google Tasks API" and click "Enable"
 
 #### 2. Create OAuth 2.0 Credentials
 
@@ -96,10 +103,12 @@ If you need **each user to authenticate with their own Google account**, this se
 # 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=
+
+# Default timezone for calendar operations
+DEFAULT_TIMEZONE=Atlantic/Canary
 ```
 
 #### 4. Get the refresh token
@@ -138,8 +147,8 @@ Add this to your MCP client configuration (e.g., Claude Desktop config):
       "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>"
+        "GOOGLE_REFRESH_TOKEN": "<your-refresh-token>",
+        "DEFAULT_TIMEZONE": "Atlantic/Canary"
       }
     }
   }
@@ -171,8 +180,8 @@ npm run build
 ```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
+DEFAULT_TIMEZONE=Atlantic/Canary
 ```
 
 3. Update `mcp-inspector-config.json` with your project path:
@@ -185,8 +194,8 @@ GOOGLE_REFRESH_TOKEN=your-refresh-token
       "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}"
+        "GOOGLE_REFRESH_TOKEN": "${GOOGLE_REFRESH_TOKEN}",
+        "DEFAULT_TIMEZONE": "${DEFAULT_TIMEZONE}"
       }
     }
   }
@@ -201,22 +210,44 @@ 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.
 
 
+## Timezone Configuration
+
+This MCP server supports flexible timezone configuration:
+
+1. **Default Timezone**: Set `DEFAULT_TIMEZONE` in your `.env` file using IANA timezone format (e.g., `Atlantic/Canary`, `America/New_York`, `Asia/Tokyo`)
+2. **Per-Operation Override**: When creating or updating events, you can specify a different timezone for that specific operation
+3. **Fallback**: If no timezone is configured, the server defaults to `Atlantic/Canary`
+
+**Timezone Priority:**
+1. Timezone parameter passed to the tool (highest priority)
+2. `DEFAULT_TIMEZONE` environment variable from `.env`
+3. Hardcoded default: `Atlantic/Canary` (lowest priority)
+
+**Common IANA Timezones:**
+- Europe: `Atlantic/Canary`, `Europe/London`, `Europe/Paris`, `Europe/Berlin`
+- Americas: `America/New_York`, `America/Chicago`, `America/Los_Angeles`, `America/Mexico_City`
+- Asia: `Asia/Tokyo`, `Asia/Shanghai`, `Asia/Dubai`, `Asia/Kolkata`
+- Other: `Atlantic/Canary`, `Pacific/Auckland`, `Australia/Sydney`
+
 ## Security
 
 - **Never** share your `client_secret` or `refresh_token`
 - Add `.env` to your `.gitignore` (already included)
-- Tokens have limited permissions only for Google Calendar
+- Tokens have limited permissions only for Google Calendar and Google Tasks
 
 ## Additional Resources
 
 - [Google Calendar API Documentation](https://developers.google.com/calendar/api)
+- [Google Tasks API Documentation](https://developers.google.com/tasks)
 - [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
+### Calendar Tools
+
+#### calendar-create-event
 
 Creates a new calendar event in Google Calendar.
 
@@ -226,12 +257,14 @@ Parameters:
 - `end`: DateTime string - Event end time (ISO 8601 format)
 - `description`: String (optional) - Event description
 - `location`: String (optional) - Event location
+- `attendees`: Array of email strings (optional) - List of attendee email addresses
+- `timeZone`: String (optional) - Timezone in IANA format (e.g., Atlantic/Canary, America/New_York). Defaults to `DEFAULT_TIMEZONE` from .env or 'Atlantic/Canary'
 - `calendarId`: String (optional) - Calendar ID (defaults to 'primary')
 
 Returns:
 - The unique ID and details of the created event
 
-### google-update-event
+#### calendar-update-event
 
 Updates an existing event in Google Calendar.
 
@@ -242,12 +275,14 @@ Parameters:
 - `end`: DateTime string (optional) - New event end time (ISO 8601 format)
 - `description`: String (optional) - New event description
 - `location`: String (optional) - New event location
+- `attendees`: Array of email strings (optional) - List of attendee email addresses
+- `timeZone`: String (optional) - Timezone in IANA format (e.g., Atlantic/Canary, America/New_York). Defaults to `DEFAULT_TIMEZONE` from .env or 'Atlantic/Canary'
 - `calendarId`: String (optional) - Calendar ID (defaults to 'primary')
 
 Returns:
 - The updated event details
 
-### google-list-events
+#### calendar-list-events
 
 Lists events within a specified timeframe from Google Calendar.
 
@@ -260,7 +295,7 @@ Parameters:
 Returns:
 - A list of events that fall within the given timeframe
 
-### google-search-events
+#### calendar-search-events
 
 Searches for events in Google Calendar by text query.
 
@@ -272,7 +307,7 @@ Parameters:
 Returns:
 - A list of events matching the search query
 
-### google-delete-event
+#### calendar-delete-event
 
 Deletes an event from Google Calendar.
 
@@ -283,23 +318,90 @@ Parameters:
 Returns:
 - Confirmation of deletion
 
-### google-list-calendars
+#### calendar-list-calendars
 
 Lists all calendars available to the user.
 
 Returns:
 - A list of calendars with their IDs and names
 
-### google-get-current-datetime
+#### calendar-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'.
+- `timezone`: String (optional) - Timezone in IANA format (e.g., Atlantic/Canary, America/New_York, Asia/Tokyo). Defaults to `DEFAULT_TIMEZONE` from .env or 'Atlantic/Canary'.
 
 Returns:
 - Current date and time information including ISO 8601 format, timestamp, local time, and timezone details
 
+### Tasks Tools
+
+#### tasks-list-task-lists
+
+Lists all task lists available in Google Tasks.
+
+Parameters: None
+
+Returns:
+- A list of all task lists with their IDs and titles
+
+Example use case:
+- Get the list of all your task lists to find the `taskListId` for creating or managing tasks
+
+#### tasks-list-tasks
+
+Lists all tasks in a specific task list.
+
+Parameters:
+- `taskListId`: String - The ID of the task list (use `tasks-list-task-lists` to get this)
+- `showCompleted`: Boolean (optional) - Whether to show completed tasks (default: true)
+- `maxResults`: Number (optional) - Maximum number of tasks to return (default: 100)
+
+Returns:
+- A list of tasks with details including ID, title, notes, status, due date, and completion date
+
+#### tasks-create-task
+
+Creates a new task in Google Tasks.
+
+Parameters:
+- `taskListId`: String - The ID of the task list where the task will be created
+- `title`: String - Task title/summary
+- `notes`: String (optional) - Task notes or description
+- `due`: DateTime string (optional) - Due date in ISO 8601 format (e.g., "2024-12-31T23:59:59Z")
+
+Returns:
+- The created task details including ID, title, notes, status, and due date
+
+
+#### tasks-update-task
+
+Updates an existing task in Google Tasks.
+
+Parameters:
+- `taskListId`: String - The ID of the task list containing the task
+- `taskId`: String - The ID of the task to update
+- `title`: String (optional) - New task title
+- `notes`: String (optional) - New task notes or description
+- `due`: DateTime string (optional) - New due date in ISO 8601 format
+- `status`: String (optional) - Task status: either "needsAction" or "completed"
+
+Returns:
+- The updated task details
+
+
+#### tasks-delete-task
+
+Deletes a task from Google Tasks.
+
+Parameters:
+- `taskListId`: String - The ID of the task list containing the task
+- `taskId`: String - The ID of the task to delete
+
+Returns:
+- Confirmation message of deletion
+
 ## License
 
 MIT

package/dist/index.js

@@ -2,11 +2,11 @@
 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 { GoogleCalendarClient } from "./tools/google-calendar-client.js";
 import { registerGoogleCalendarTools } from "./tools/google-calendar-mcp.js";
 const server = new McpServer({
     name: "mcp-google-calendar",
-    version: "1.0.2",
+    version: "1.1.0",
 });
 async function main() {
     console.error('Configurando Google Calendar API...');
@@ -18,7 +18,6 @@ async function main() {
     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

package/dist/tools/{google-create-event.js → calendar/calendar-create-event.js}

@@ -1,16 +1,18 @@
-import { createSimpleEvent } from './google-calendar.js';
+import { createSimpleEvent } from '../google-calendar-client.js';
 import { z } from 'zod';
 export function registerGoogleCreateEvent(googleClient, server) {
-    server.tool('google_create_event', 'Crea un nuevo evento en Google Calendar', {
+    server.tool('calendar_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)'),
+        attendees: z.array(z.string().email()).optional().describe('Lista de emails de los invitados (opcional)'),
+        timeZone: z.string().optional().describe('Zona horaria en formato IANA (ej: America/New_York, Atlantic/Canary). Por defecto usa DEFAULT_TIMEZONE del .env'),
     }, async (args) => {
         try {
-            const { calendarId = 'primary', title, start, end, description, location, } = args;
+            const { calendarId = 'primary', title, start, end, description, location, attendees, timeZone, } = args;
             if (!title || !start || !end) {
                 return {
                     content: [
@@ -22,13 +24,17 @@ export function registerGoogleCreateEvent(googleClient, server) {
                     isError: true,
                 };
             }
-            const event = createSimpleEvent(title, start, end, description, location);
+            const event = createSimpleEvent(title, start, end, description, location, attendees, timeZone);
             const createdEvent = await googleClient.createEvent(calendarId, event);
+            let successMessage = `Evento creado exitosamente:\nID: ${createdEvent.id}\nTítulo: ${createdEvent.summary}\nInicio: ${createdEvent.start?.dateTime}\nFin: ${createdEvent.end?.dateTime}`;
+            if (attendees && attendees.length > 0) {
+                successMessage += `\nInvitados: ${attendees.join(', ')}`;
+            }
             return {
                 content: [
                     {
                         type: 'text',
-                        text: `Evento creado exitosamente:\nID: ${createdEvent.id}\nTítulo: ${createdEvent.summary}\nInicio: ${createdEvent.start?.dateTime}\nFin: ${createdEvent.end?.dateTime}`,
+                        text: successMessage,
                     },
                 ],
             };

package/dist/tools/{google-delete-event.js → calendar/calendar-delete-event.js}

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 export function registerGoogleDeleteEvent(googleClient, server) {
-    server.tool('google_delete_event', 'Elimina un evento de Google Calendar', {
+    server.tool('calendar_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) => {

package/dist/tools/{google-get-current-datetime.js → calendar/calendar-get-current-datetime.js}

@@ -1,10 +1,10 @@
 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.'),
+    server.tool('calendar_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, Atlantic/Canary). Por defecto usa DEFAULT_TIMEZONE del .env'),
     }, async (args) => {
         try {
-            const { timezone = 'Atlantic/Canary' } = args;
+            const { timezone = process.env.DEFAULT_TIMEZONE || 'Atlantic/Canary' } = args;
             const now = new Date();
             // Información básica
             const isoString = now.toISOString();
@@ -40,7 +40,7 @@ export function registerGoogleGetCurrentDatetime(googleClient, server) {
                     content: [
                         {
                             type: 'text',
-                            text: `Error: Zona horaria inválida '${timezone}'. Usa formato IANA (ej: America/New_York, Europe/Madrid, Atlantic/Canary)`,
+                            text: `Error: Zona horaria inválida '${timezone}'. Usa formato IANA (ej: America/New_York, Atlantic/Canary, Atlantic/Canary)`,
                         },
                     ],
                     isError: true,

package/dist/tools/{google-list-calendars.js → calendar/calendar-list-calendars.js}

@@ -1,5 +1,5 @@
 export function registerGoogleListCalendars(googleClient, server) {
-    server.tool('google_list_calendars', 'Lista todos los calendarios disponibles en Google Calendar', async () => {
+    server.tool('calendar_list_calendars', 'Lista todos los calendarios disponibles en Google Calendar', async () => {
         try {
             const calendars = await googleClient.listCalendars();
             const data = calendars.map((cal) => ({

package/dist/tools/{google-list-events.js → calendar/calendar-list-events.js}

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 export function registerGoogleListEvents(googleClient, server) {
-    server.tool('google_list_events', 'Lista eventos de un calendario de Google Calendar', {
+    server.tool('calendar_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'),

package/dist/tools/{google-search-events.js → calendar/calendar-search-events.js}

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 export function registerGoogleSearchEvents(googleClient, server) {
-    server.tool('google_search_events', 'Busca eventos en Google Calendar por texto', {
+    server.tool('calendar_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)'),

package/dist/tools/{google-update-event.js → calendar/calendar-update-event.js}

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 export function registerGoogleUpdateEvent(googleClient, server) {
-    server.tool('google_update_event', 'Actualiza un evento existente en Google Calendar', {
+    server.tool('calendar_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'),
@@ -8,9 +8,11 @@ export function registerGoogleUpdateEvent(googleClient, server) {
         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'),
+        attendees: z.array(z.string().email()).optional().describe('Lista de emails de los invitados (opcional)'),
+        timeZone: z.string().optional().describe('Zona horaria en formato IANA (ej: America/New_York, Atlantic/Canary). Por defecto usa DEFAULT_TIMEZONE del .env'),
     }, async (args) => {
         try {
-            const { calendarId = 'primary', eventId, title, start, end, description, location, } = args;
+            const { calendarId = 'primary', eventId, title, start, end, description, location, attendees, timeZone, } = args;
             if (!eventId) {
                 return {
                     content: [
@@ -33,24 +35,35 @@ export function registerGoogleUpdateEvent(googleClient, server) {
             if (location !== undefined) {
                 event.location = location;
             }
+            const defaultTimeZone = timeZone || process.env.DEFAULT_TIMEZONE || 'Atlantic/Canary';
             if (start !== undefined) {
                 event.start = {
                     dateTime: start,
-                    timeZone: 'America/Mexico_City',
+                    timeZone: defaultTimeZone,
                 };
             }
             if (end !== undefined) {
                 event.end = {
                     dateTime: end,
-                    timeZone: 'America/Mexico_City',
+                    timeZone: defaultTimeZone,
                 };
             }
+            if (attendees !== undefined) {
+                event.attendees = attendees.map(email => ({
+                    email: email.trim(),
+                    responseStatus: 'needsAction'
+                }));
+            }
             const updatedEvent = await googleClient.updateEvent(calendarId, eventId, event);
+            let successMessage = `Evento actualizado exitosamente:\nID: ${updatedEvent.id}\nTítulo: ${updatedEvent.summary}\nInicio: ${updatedEvent.start?.dateTime}\nFin: ${updatedEvent.end?.dateTime}`;
+            if (attendees !== undefined && attendees.length > 0) {
+                successMessage += `\nInvitados: ${attendees.join(', ')}`;
+            }
             return {
                 content: [
                     {
                         type: 'text',
-                        text: `Evento actualizado exitosamente:\nID: ${updatedEvent.id}\nTítulo: ${updatedEvent.summary}\nInicio: ${updatedEvent.start?.dateTime}\nFin: ${updatedEvent.end?.dateTime}`,
+                        text: successMessage,
                     },
                 ],
             };

package/dist/tools/{google-calendar.js → google-calendar-client.js}

@@ -2,14 +2,16 @@ import { google } from 'googleapis';
 export class GoogleCalendarClient {
     auth;
     calendar;
+    tasks;
     constructor(config) {
-        this.auth = new google.auth.OAuth2(config.clientId, config.clientSecret, config.redirectUrl);
+        this.auth = new google.auth.OAuth2(config.clientId, config.clientSecret, 'http://localhost:8080/oauth/callback');
         if (config.refreshToken) {
             this.auth.setCredentials({
                 refresh_token: config.refreshToken,
             });
         }
         this.calendar = google.calendar({ version: 'v3', auth: this.auth });
+        this.tasks = google.tasks({ version: 'v1', auth: this.auth });
     }
     /**
      * Genera URL de autorización para obtener el token inicial
@@ -17,7 +19,8 @@ export class GoogleCalendarClient {
     getAuthUrl() {
         const scopes = [
             'https://www.googleapis.com/auth/calendar',
-            'https://www.googleapis.com/auth/calendar.events'
+            'https://www.googleapis.com/auth/calendar.events',
+            'https://www.googleapis.com/auth/tasks'
         ];
         return this.auth.generateAuthUrl({
             access_type: 'offline',
@@ -132,22 +135,129 @@ export class GoogleCalendarClient {
             throw error;
         }
     }
+    // ========== Google Tasks Methods ==========
+    /**
+     * Lista todas las listas de tareas del usuario
+     */
+    async listTaskLists() {
+        try {
+            const response = await this.tasks.tasklists.list();
+            return response.data.items || [];
+        }
+        catch (error) {
+            console.error('Error al listar listas de tareas:', error);
+            throw error;
+        }
+    }
+    /**
+     * Lista todas las tareas de una lista específica
+     */
+    async listTasks(taskListId, showCompleted = true, maxResults = 100) {
+        try {
+            const response = await this.tasks.tasks.list({
+                tasklist: taskListId,
+                showCompleted,
+                maxResults,
+            });
+            return response.data.items || [];
+        }
+        catch (error) {
+            console.error('Error al listar tareas:', error);
+            throw error;
+        }
+    }
+    /**
+     * Crea una nueva tarea
+     */
+    async createTask(taskListId, task) {
+        try {
+            const response = await this.tasks.tasks.insert({
+                tasklist: taskListId,
+                requestBody: task,
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error('Error al crear tarea:', error);
+            throw error;
+        }
+    }
+    /**
+     * Actualiza una tarea existente
+     */
+    async updateTask(taskListId, taskId, task) {
+        try {
+            const response = await this.tasks.tasks.update({
+                tasklist: taskListId,
+                task: taskId,
+                requestBody: task,
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error('Error al actualizar tarea:', error);
+            throw error;
+        }
+    }
+    /**
+     * Elimina una tarea
+     */
+    async deleteTask(taskListId, taskId) {
+        try {
+            await this.tasks.tasks.delete({
+                tasklist: taskListId,
+                task: taskId,
+            });
+        }
+        catch (error) {
+            console.error('Error al eliminar tarea:', error);
+            throw error;
+        }
+    }
+    /**
+     * Marca una tarea como completada
+     */
+    async completeTask(taskListId, taskId) {
+        try {
+            // Primero obtenemos la tarea para no perder información
+            const taskResponse = await this.tasks.tasks.get({
+                tasklist: taskListId,
+                task: taskId,
+            });
+            const task = taskResponse.data;
+            task.status = 'completed';
+            task.completed = new Date().toISOString();
+            return await this.updateTask(taskListId, taskId, task);
+        }
+        catch (error) {
+            console.error('Error al completar tarea:', error);
+            throw error;
+        }
+    }
 }
 /**
  * Función helper para crear eventos con formato simplificado
  */
-export function createSimpleEvent(title, start, end, description, location) {
-    return {
+export function createSimpleEvent(title, start, end, description, location, attendees, timeZone) {
+    const defaultTimeZone = timeZone || process.env.DEFAULT_TIMEZONE || 'Atlantic/Canary';
+    const event = {
         summary: title,
         description,
         location,
         start: {
             dateTime: start,
-            timeZone: 'America/Mexico_City', // Ajusta según tu zona horaria
+            timeZone: defaultTimeZone,
         },
         end: {
             dateTime: end,
-            timeZone: 'America/Mexico_City',
+            timeZone: defaultTimeZone,
         },
     };
+    if (attendees && attendees.length > 0) {
+        event.attendees = attendees.map(email => ({
+            email: email.trim(),
+            responseStatus: 'needsAction'
+        }));
+    }
+    return event;
 }

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

@@ -1,11 +1,17 @@
-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';
+import { registerGoogleListCalendars } from './calendar/calendar-list-calendars.js';
+import { registerGoogleListEvents } from './calendar/calendar-list-events.js';
+import { registerGoogleCreateEvent } from './calendar/calendar-create-event.js';
+import { registerGoogleUpdateEvent } from './calendar/calendar-update-event.js';
+import { registerGoogleDeleteEvent } from './calendar/calendar-delete-event.js';
+import { registerGoogleSearchEvents } from './calendar/calendar-search-events.js';
+import { registerGoogleGetCurrentDatetime } from './calendar/calendar-get-current-datetime.js';
+import { registerTasksListTaskLists } from './tasks/tasks-list-task-lists.js';
+import { registerTasksListTasks } from './tasks/tasks-list-tasks.js';
+import { registerTasksCreateTask } from './tasks/tasks-create-task.js';
+import { registerTasksUpdateTask } from './tasks/tasks-update-task.js';
+import { registerTasksDeleteTask } from './tasks/tasks-delete-task.js';
 export function registerGoogleCalendarTools(googleClient, server) {
+    // Calendar tools
     registerGoogleListCalendars(googleClient, server);
     registerGoogleListEvents(googleClient, server);
     registerGoogleCreateEvent(googleClient, server);
@@ -13,4 +19,10 @@ export function registerGoogleCalendarTools(googleClient, server) {
     registerGoogleDeleteEvent(googleClient, server);
     registerGoogleSearchEvents(googleClient, server);
     registerGoogleGetCurrentDatetime(googleClient, server);
+    // Tasks tools
+    registerTasksListTaskLists(googleClient, server);
+    registerTasksListTasks(googleClient, server);
+    registerTasksCreateTask(googleClient, server);
+    registerTasksUpdateTask(googleClient, server);
+    registerTasksDeleteTask(googleClient, server);
 }

package/dist/tools/tasks/tasks-create-task.js

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+export function registerTasksCreateTask(googleClient, server) {
+    server.tool('tasks_create_task', 'Crea una nueva tarea en Google Tasks', {
+        taskListId: z.string().describe('ID de la lista de tareas (usa tasks_list_task_lists para obtenerlo)'),
+        title: z.string().describe('Título de la tarea'),
+        notes: z.string().optional().describe('Notas o descripción de la tarea'),
+        due: z.string().optional().describe('Fecha de vencimiento en formato ISO (ej: 2023-12-31T23:59:59Z)'),
+    }, async (args) => {
+        try {
+            const { taskListId, title, notes, due, } = args;
+            const task = {
+                title,
+                notes,
+                due,
+                status: 'needsAction',
+            };
+            const createdTask = await googleClient.createTask(taskListId, task);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            id: createdTask.id,
+                            title: createdTask.title,
+                            notes: createdTask.notes,
+                            status: createdTask.status,
+                            due: createdTask.due,
+                            created: createdTask.updated,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Error desconocido';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error al crear tarea: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/tasks/tasks-delete-task.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export function registerTasksDeleteTask(googleClient, server) {
+    server.tool('tasks_delete_task', 'Elimina una tarea de Google Tasks', {
+        taskListId: z.string().describe('ID de la lista de tareas'),
+        taskId: z.string().describe('ID de la tarea a eliminar'),
+    }, async (args) => {
+        try {
+            const { taskListId, taskId } = args;
+            await googleClient.deleteTask(taskListId, taskId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Tarea ${taskId} eliminada exitosamente de la lista ${taskListId}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Error desconocido';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error al eliminar tarea: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/tasks/tasks-list-task-lists.js

@@ -0,0 +1,32 @@
+export function registerTasksListTaskLists(googleClient, server) {
+    server.tool('tasks_list_task_lists', 'Lista todas las listas de tareas de Google Tasks del usuario', {}, async () => {
+        try {
+            const taskLists = await googleClient.listTaskLists();
+            const data = taskLists.map((taskList) => ({
+                id: taskList.id,
+                title: taskList.title,
+                updated: taskList.updated,
+            }));
+            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 listas de tareas: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/tasks/tasks-list-tasks.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export function registerTasksListTasks(googleClient, server) {
+    server.tool('tasks_list_tasks', 'Lista todas las tareas de una lista de tareas específica en Google Tasks', {
+        taskListId: z.string().describe('ID de la lista de tareas (usa tasks_list_task_lists para obtenerlo)'),
+        showCompleted: z.boolean().optional().describe('Mostrar tareas completadas (por defecto: true)'),
+        maxResults: z.number().optional().describe('Número máximo de resultados (por defecto: 100)'),
+    }, async (args) => {
+        try {
+            const { taskListId, showCompleted = true, maxResults = 100, } = args;
+            const tasks = await googleClient.listTasks(taskListId, showCompleted, maxResults);
+            const data = tasks.map((task) => ({
+                id: task.id,
+                title: task.title,
+                notes: task.notes,
+                status: task.status,
+                due: task.due,
+                completed: task.completed,
+                updated: task.updated,
+                parent: task.parent,
+            }));
+            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 tareas: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/tasks/tasks-update-task.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+export function registerTasksUpdateTask(googleClient, server) {
+    server.tool('tasks_update_task', 'Actualiza una tarea existente en Google Tasks', {
+        taskListId: z.string().describe('ID de la lista de tareas'),
+        taskId: z.string().describe('ID de la tarea a actualizar'),
+        title: z.string().optional().describe('Nuevo título de la tarea'),
+        notes: z.string().optional().describe('Nuevas notas o descripción de la tarea'),
+        due: z.string().optional().describe('Nueva fecha de vencimiento en formato ISO (ej: 2023-12-31T23:59:59Z)'),
+        status: z.enum(['needsAction', 'completed']).optional().describe('Estado de la tarea'),
+    }, async (args) => {
+        try {
+            const { taskListId, taskId, title, notes, due, status, } = args;
+            const task = {};
+            if (title !== undefined)
+                task.title = title;
+            if (notes !== undefined)
+                task.notes = notes;
+            if (due !== undefined)
+                task.due = due;
+            if (status !== undefined) {
+                task.status = status;
+                if (status === 'completed') {
+                    task.completed = new Date().toISOString();
+                }
+            }
+            const updatedTask = await googleClient.updateTask(taskListId, taskId, task);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            id: updatedTask.id,
+                            title: updatedTask.title,
+                            notes: updatedTask.notes,
+                            status: updatedTask.status,
+                            due: updatedTask.due,
+                            completed: updatedTask.completed,
+                            updated: updatedTask.updated,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Error desconocido';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error al actualizar tarea: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pablosr/mcp-google-calendar",
   "description": "A Google Calendar (MCP) server to expose calendar operations as tools for LLM.",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "main": "dist/index.js",
   "type": "module",
   "bin": "dist/index.js",