google-tools-mcp 1.2.5 → 1.2.6

package/dist/auth.js

@@ -54,6 +54,8 @@ const SCOPES = [
     'https://www.googleapis.com/auth/forms.responses.readonly',
     // Slides
     'https://www.googleapis.com/auth/presentations',
+    // Tasks
+    'https://www.googleapis.com/auth/tasks',
 ];
 
 // ---------------------------------------------------------------------------

package/dist/clients.js

@@ -14,6 +14,7 @@ let gmailClient = null;
 let calendarClient = null;
 let formsClient = null;
 let slidesClient = null;
+let tasksClient = null;
 
 async function ensureAuth() {
     if (authClient) return;
@@ -46,6 +47,7 @@ async function reauthorize() {
     calendarClient = null;
     formsClient = null;
     slidesClient = null;
+    tasksClient = null;
     authClient = await authorize();
     logger.info('Re-authorization successful.');
 }
@@ -120,6 +122,7 @@ export function resetClients() {
     calendarClient = null;
     formsClient = null;
     slidesClient = null;
+    tasksClient = null;
 }
 
 /**
@@ -194,3 +197,17 @@ export async function getSlidesClient() {
     if (!slides) throw new UserError('Google Slides client is not initialized.');
     return slides;
 }
+
+// --- Tasks client ---
+export async function initializeTasksClient() {
+    if (tasksClient) return { authClient, tasksClient };
+    await ensureAuth();
+    if (!tasksClient) tasksClient = google.tasks({ version: 'v1', auth: authClient });
+    return { authClient, tasksClient };
+}
+
+export async function getTasksClient() {
+    const { tasksClient: tasks } = await initializeTasksClient();
+    if (!tasks) throw new UserError('Google Tasks client is not initialized.');
+    return tasks;
+}

package/dist/tools/index.js

@@ -178,6 +178,12 @@ const CATEGORIES = {
             registerSlidesTools(server);
         },
     },
+    tasks: {
+        async loader(server) {
+            const { registerTasksTools } = await import('./tasks/index.js');
+            registerTasksTools(server);
+        },
+    },
 };
 
 // ---------------------------------------------------------------------------

package/dist/tools/tasks/completeTask.js

@@ -0,0 +1,43 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getTasksClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'completeTask',
+        description: 'Marks a task as completed.',
+        parameters: z.object({
+            taskListId: z.string().describe('ID of the task list containing the task'),
+            taskId: z.string().describe('ID of the task to complete'),
+        }),
+        execute: async (args, { log }) => {
+            const tasks = await getTasksClient();
+            log.info(`Completing task ${args.taskId} in list: ${args.taskListId}`);
+
+            try {
+                const response = await tasks.tasks.patch({
+                    tasklist: args.taskListId,
+                    task: args.taskId,
+                    requestBody: { status: 'completed', completed: new Date().toISOString() },
+                });
+                const t = response.data;
+                return JSON.stringify({
+                    id: t.id,
+                    taskListId: args.taskListId,
+                    title: t.title || '',
+                    notes: t.notes || null,
+                    status: t.status,
+                    due: t.due || null,
+                    completed: t.completed || null,
+                }, null, 2);
+            } catch (error) {
+                log.error(`Error completing task: ${error.message || error}`);
+                if (error.code === 404)
+                    throw new UserError(`Task not found (taskId: ${args.taskId}, listId: ${args.taskListId}).`);
+                if (error.code === 403)
+                    throw new UserError('Permission denied. Make sure you have access to this task.');
+                throw new UserError(`Failed to complete task: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/tasks/createTask.js

@@ -0,0 +1,53 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getTasksClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'createTask',
+        description: 'Creates a new task in a Google Tasks task list.',
+        parameters: z.object({
+            taskListId: z.string().describe('ID of the task list to add the task to'),
+            title: z.string().describe('Title of the task'),
+            notes: z.string().optional().describe('Optional notes or description for the task'),
+            due: z
+                .string()
+                .optional()
+                .describe('Optional due date in RFC 3339 or plain date format (e.g. "2025-04-30")'),
+        }),
+        execute: async (args, { log }) => {
+            const tasks = await getTasksClient();
+            log.info(`Creating task "${args.title}" in list: ${args.taskListId}`);
+
+            try {
+                const body = { title: args.title };
+                if (args.notes) body.notes = args.notes;
+                if (args.due) body.due = normalizeDate(args.due);
+
+                const response = await tasks.tasks.insert({ tasklist: args.taskListId, requestBody: body });
+                const t = response.data;
+                return JSON.stringify({
+                    id: t.id,
+                    taskListId: args.taskListId,
+                    title: t.title || '',
+                    notes: t.notes || null,
+                    status: t.status,
+                    due: t.due || null,
+                    completed: t.completed || null,
+                }, null, 2);
+            } catch (error) {
+                log.error(`Error creating task: ${error.message || error}`);
+                if (error.code === 404)
+                    throw new UserError(`Task list not found (ID: ${args.taskListId}).`);
+                if (error.code === 403)
+                    throw new UserError('Permission denied. Make sure you have access to this task list.');
+                throw new UserError(`Failed to create task: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}
+
+function normalizeDate(value) {
+    if (/^\d{4}-\d{2}-\d{2}$/.test(value)) return `${value}T00:00:00.000Z`;
+    return value;
+}

package/dist/tools/tasks/createTaskList.js

@@ -0,0 +1,25 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getTasksClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'createTaskList',
+        description: 'Creates a new Google Tasks task list with the given title.',
+        parameters: z.object({
+            title: z.string().describe('Title for the new task list'),
+        }),
+        execute: async (args, { log }) => {
+            const tasks = await getTasksClient();
+            log.info(`Creating task list: ${args.title}`);
+
+            try {
+                const response = await tasks.tasklists.insert({ requestBody: { title: args.title } });
+                return JSON.stringify({ id: response.data.id, title: response.data.title }, null, 2);
+            } catch (error) {
+                log.error(`Error creating task list: ${error.message || error}`);
+                throw new UserError(`Failed to create task list: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/tasks/deleteTask.js

@@ -0,0 +1,30 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getTasksClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'deleteTask',
+        description: 'Permanently deletes a task.',
+        parameters: z.object({
+            taskListId: z.string().describe('ID of the task list containing the task'),
+            taskId: z.string().describe('ID of the task to delete'),
+        }),
+        execute: async (args, { log }) => {
+            const tasks = await getTasksClient();
+            log.info(`Deleting task ${args.taskId} from list: ${args.taskListId}`);
+
+            try {
+                await tasks.tasks.delete({ tasklist: args.taskListId, task: args.taskId });
+                return JSON.stringify({ deleted: true, taskId: args.taskId, taskListId: args.taskListId }, null, 2);
+            } catch (error) {
+                log.error(`Error deleting task: ${error.message || error}`);
+                if (error.code === 404)
+                    throw new UserError(`Task not found (taskId: ${args.taskId}, listId: ${args.taskListId}).`);
+                if (error.code === 403)
+                    throw new UserError('Permission denied. Make sure you have access to this task.');
+                throw new UserError(`Failed to delete task: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/tasks/deleteTaskList.js

@@ -0,0 +1,29 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getTasksClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'deleteTaskList',
+        description: 'Permanently deletes a task list and all tasks within it.',
+        parameters: z.object({
+            taskListId: z.string().describe('ID of the task list to delete'),
+        }),
+        execute: async (args, { log }) => {
+            const tasks = await getTasksClient();
+            log.info(`Deleting task list: ${args.taskListId}`);
+
+            try {
+                await tasks.tasklists.delete({ tasklist: args.taskListId });
+                return JSON.stringify({ deleted: true, taskListId: args.taskListId }, null, 2);
+            } catch (error) {
+                log.error(`Error deleting task list: ${error.message || error}`);
+                if (error.code === 404)
+                    throw new UserError(`Task list not found (ID: ${args.taskListId}).`);
+                if (error.code === 403)
+                    throw new UserError('Permission denied. You can only delete task lists you own.');
+                throw new UserError(`Failed to delete task list: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/tasks/index.js

@@ -0,0 +1,19 @@
+import { register as listTaskLists } from './listTaskLists.js';
+import { register as createTaskList } from './createTaskList.js';
+import { register as deleteTaskList } from './deleteTaskList.js';
+import { register as listTasks } from './listTasks.js';
+import { register as createTask } from './createTask.js';
+import { register as updateTask } from './updateTask.js';
+import { register as completeTask } from './completeTask.js';
+import { register as deleteTask } from './deleteTask.js';
+
+export function registerTasksTools(server) {
+    listTaskLists(server);
+    createTaskList(server);
+    deleteTaskList(server);
+    listTasks(server);
+    createTask(server);
+    updateTask(server);
+    completeTask(server);
+    deleteTask(server);
+}

package/dist/tools/tasks/listTaskLists.js

@@ -0,0 +1,26 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getTasksClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'listTaskLists',
+        description: 'Lists all Google Task lists for the authenticated user. Returns the id and title of each list.',
+        parameters: z.object({}),
+        execute: async (_args, { log }) => {
+            const tasks = await getTasksClient();
+            log.info('Listing task lists');
+
+            try {
+                const response = await tasks.tasklists.list();
+                const lists = response.data.items || [];
+                return JSON.stringify(lists.map((l) => ({ id: l.id, title: l.title })), null, 2);
+            } catch (error) {
+                log.error(`Error listing task lists: ${error.message || error}`);
+                if (error.code === 401)
+                    throw new UserError('Authentication failed. Try logging out and re-authenticating.');
+                throw new UserError(`Failed to list task lists: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/tasks/listTasks.js

@@ -0,0 +1,69 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getTasksClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'listTasks',
+        description:
+            'Lists tasks in a Google Tasks task list. Optionally filter by completion status or due date range.',
+        parameters: z.object({
+            taskListId: z.string().describe('ID of the task list to read from'),
+            showCompleted: z
+                .boolean()
+                .optional()
+                .describe('Whether to include completed tasks (default: true)'),
+            dueMin: z
+                .string()
+                .optional()
+                .describe('Lower bound for due date filter, RFC 3339 or plain date (e.g. "2025-04-01")'),
+            dueMax: z
+                .string()
+                .optional()
+                .describe('Upper bound for due date filter, RFC 3339 or plain date (e.g. "2025-04-30")'),
+        }),
+        execute: async (args, { log }) => {
+            const tasks = await getTasksClient();
+            const showCompleted = args.showCompleted ?? true;
+            log.info(`Listing tasks in list: ${args.taskListId}`);
+
+            try {
+                const params = {
+                    tasklist: args.taskListId,
+                    showCompleted,
+                    showHidden: showCompleted,
+                };
+                if (args.dueMin) params.dueMin = normalizeDate(args.dueMin);
+                if (args.dueMax) params.dueMax = normalizeDate(args.dueMax);
+
+                const response = await tasks.tasks.list(params);
+                const items = response.data.items || [];
+                return JSON.stringify(items.map((t) => formatTask(t, args.taskListId)), null, 2);
+            } catch (error) {
+                log.error(`Error listing tasks: ${error.message || error}`);
+                if (error.code === 404)
+                    throw new UserError(`Task list not found (ID: ${args.taskListId}).`);
+                if (error.code === 403)
+                    throw new UserError('Permission denied. Make sure you have access to this task list.');
+                throw new UserError(`Failed to list tasks: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}
+
+function formatTask(t, taskListId) {
+    return {
+        id: t.id,
+        taskListId,
+        title: t.title || '',
+        notes: t.notes || null,
+        status: t.status,
+        due: t.due || null,
+        completed: t.completed || null,
+    };
+}
+
+function normalizeDate(value) {
+    if (/^\d{4}-\d{2}-\d{2}$/.test(value)) return `${value}T00:00:00.000Z`;
+    return value;
+}

package/dist/tools/tasks/updateTask.js

@@ -0,0 +1,68 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getTasksClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'updateTask',
+        description:
+            'Updates fields on an existing task. Only provided fields are changed; omitted fields are left as-is.',
+        parameters: z.object({
+            taskListId: z.string().describe('ID of the task list containing the task'),
+            taskId: z.string().describe('ID of the task to update'),
+            title: z.string().optional().describe('New title for the task'),
+            notes: z.string().optional().describe('New notes for the task'),
+            due: z
+                .string()
+                .optional()
+                .describe('New due date in RFC 3339 or plain date format (e.g. "2025-04-30")'),
+            status: z
+                .enum(['needsAction', 'completed'])
+                .optional()
+                .describe('New status for the task'),
+        }),
+        execute: async (args, { log }) => {
+            const tasks = await getTasksClient();
+            log.info(`Updating task ${args.taskId} in list: ${args.taskListId}`);
+
+            try {
+                const body = {};
+                if (args.title !== undefined) body.title = args.title;
+                if (args.notes !== undefined) body.notes = args.notes;
+                if (args.due !== undefined) body.due = normalizeDate(args.due);
+                if (args.status !== undefined) {
+                    body.status = args.status;
+                    if (args.status === 'completed') body.completed = new Date().toISOString();
+                }
+
+                const response = await tasks.tasks.patch({
+                    tasklist: args.taskListId,
+                    task: args.taskId,
+                    requestBody: body,
+                });
+                const t = response.data;
+                return JSON.stringify({
+                    id: t.id,
+                    taskListId: args.taskListId,
+                    title: t.title || '',
+                    notes: t.notes || null,
+                    status: t.status,
+                    due: t.due || null,
+                    completed: t.completed || null,
+                }, null, 2);
+            } catch (error) {
+                log.error(`Error updating task: ${error.message || error}`);
+                if (error.code === 404)
+                    throw new UserError(`Task not found (taskId: ${args.taskId}, listId: ${args.taskListId}).`);
+                if (error.code === 403)
+                    throw new UserError('Permission denied. Make sure you have access to this task.');
+                throw new UserError(`Failed to update task: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}
+
+function normalizeDate(value) {
+    if (/^\d{4}-\d{2}-\d{2}$/.test(value)) return `${value}T00:00:00.000Z`;
+    return value;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "google-tools-mcp",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "description": "The easiest MCP server for Google Workspace — Drive, Docs, Sheets, Gmail, Calendar, and Forms. 153 tools with one-click browser auth. Read Word docs, PDFs, and spreadsheets straight from Drive.",
   "type": "module",
   "bin": {