google-tools-mcp 1.1.1 → 1.1.3

package/dist/tools/slides/getPresentation.js

@@ -0,0 +1,87 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'getPresentation',
+        description:
+            'Get the content of a Google Slides presentation with element IDs for formatting. Optionally retrieve a single slide by index.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            slideIndex: z.number().min(0).optional().describe('Specific slide index (0-based). Omit to get all slides.'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+            log.info(`Reading presentation: ${args.presentationId}`);
+
+            try {
+                const presentation = await slidesApi.presentations.get({
+                    presentationId: args.presentationId,
+                });
+
+                if (!presentation.data.slides) {
+                    throw new UserError('No slides found in presentation');
+                }
+
+                const allSlides = presentation.data.slides;
+                const slides =
+                    args.slideIndex !== undefined ? [allSlides[args.slideIndex]] : allSlides;
+
+                const result = {
+                    title: presentation.data.title,
+                    presentationId: args.presentationId,
+                    totalSlides: allSlides.length,
+                    slides: slides.map((slide, idx) => {
+                        if (!slide?.objectId) return null;
+                        const slideInfo = {
+                            index: args.slideIndex ?? idx,
+                            objectId: slide.objectId,
+                            elements: [],
+                        };
+
+                        for (const el of slide.pageElements || []) {
+                            if (!el.objectId) continue;
+                            if (el.shape?.text) {
+                                let text = '';
+                                for (const te of el.shape.text.textElements || []) {
+                                    if (te.textRun?.content) text += te.textRun.content;
+                                }
+                                slideInfo.elements.push({
+                                    type: 'text',
+                                    objectId: el.objectId,
+                                    placeholderType: el.shape.placeholder?.type || null,
+                                    text: text.trim(),
+                                });
+                            } else if (el.shape) {
+                                slideInfo.elements.push({
+                                    type: 'shape',
+                                    objectId: el.objectId,
+                                    shapeType: el.shape.shapeType || 'Unknown',
+                                });
+                            } else if (el.image) {
+                                slideInfo.elements.push({ type: 'image', objectId: el.objectId });
+                            } else if (el.video) {
+                                slideInfo.elements.push({ type: 'video', objectId: el.objectId });
+                            } else if (el.table) {
+                                slideInfo.elements.push({
+                                    type: 'table',
+                                    objectId: el.objectId,
+                                    rows: el.table.rows,
+                                    columns: el.table.columns,
+                                });
+                            }
+                        }
+                        return slideInfo;
+                    }).filter(Boolean),
+                };
+
+                return JSON.stringify(result, null, 2);
+            } catch (error) {
+                if (error instanceof UserError) throw error;
+                log.error(`Error reading presentation: ${error.message || error}`);
+                throw new UserError(`Failed to read presentation: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/index.js

@@ -0,0 +1,33 @@
+import { register as createPresentation } from './createPresentation.js';
+import { register as updatePresentation } from './updatePresentation.js';
+import { register as getPresentation } from './getPresentation.js';
+import { register as formatText } from './formatText.js';
+import { register as formatParagraph } from './formatParagraph.js';
+import { register as styleShape } from './styleShape.js';
+import { register as setBackground } from './setBackground.js';
+import { register as createTextBox } from './createTextBox.js';
+import { register as createShape } from './createShape.js';
+import { register as speakerNotes } from './speakerNotes.js';
+import { register as deleteSlide } from './deleteSlide.js';
+import { register as duplicateSlide } from './duplicateSlide.js';
+import { register as reorderSlides } from './reorderSlides.js';
+import { register as replaceAllText } from './replaceAllText.js';
+import { register as exportThumbnail } from './exportThumbnail.js';
+
+export function registerSlidesTools(server) {
+    createPresentation(server);
+    updatePresentation(server);
+    getPresentation(server);
+    formatText(server);
+    formatParagraph(server);
+    styleShape(server);
+    setBackground(server);
+    createTextBox(server);
+    createShape(server);
+    speakerNotes(server);
+    deleteSlide(server);
+    duplicateSlide(server);
+    reorderSlides(server);
+    replaceAllText(server);
+    exportThumbnail(server);
+}

package/dist/tools/slides/reorderSlides.js

@@ -0,0 +1,41 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'reorderSlides',
+        description: 'Reorder one or more slides in a Google Slides presentation by moving them to a target index.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            slideObjectIds: z.array(z.string()).min(1).describe('Array of slide object IDs to move'),
+            insertionIndex: z.number().int().min(0).describe('Target insertion index (0-based)'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            try {
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: {
+                        requests: [
+                            {
+                                updateSlidesPosition: {
+                                    slideObjectIds: args.slideObjectIds,
+                                    insertionIndex: args.insertionIndex,
+                                },
+                            },
+                        ],
+                    },
+                });
+                return JSON.stringify({
+                    success: true,
+                    message: `Reordered ${args.slideObjectIds.length} slide(s) to index ${args.insertionIndex}`,
+                });
+            } catch (error) {
+                log.error(`Error reordering slides: ${error.message || error}`);
+                throw new UserError(`Failed to reorder slides: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/replaceAllText.js

@@ -0,0 +1,46 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'replaceAllTextInSlides',
+        description:
+            'Find and replace all matching text across all slides in a Google Slides presentation.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            containsText: z.string().describe('Text to search for'),
+            replaceText: z.string().describe('Replacement text'),
+            matchCase: z.boolean().optional().default(false).describe('Case-sensitive match'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            try {
+                const response = await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: {
+                        requests: [
+                            {
+                                replaceAllText: {
+                                    containsText: { text: args.containsText, matchCase: args.matchCase },
+                                    replaceText: args.replaceText,
+                                },
+                            },
+                        ],
+                    },
+                });
+
+                const count = response.data.replies?.[0]?.replaceAllText?.occurrencesChanged ?? 0;
+                return JSON.stringify({
+                    success: true,
+                    occurrencesChanged: count,
+                    message: `Replaced ${count} occurrence(s) of "${args.containsText}"`,
+                });
+            } catch (error) {
+                log.error(`Error replacing text: ${error.message || error}`);
+                throw new UserError(`Failed to replace text: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/setBackground.js

@@ -0,0 +1,58 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'setSlidesBackground',
+        description:
+            'Set the background color for one or more slides in a Google Slides presentation.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            pageObjectIds: z.array(z.string()).min(1).describe('Array of slide page object IDs to update'),
+            backgroundColor: z
+                .object({
+                    red: z.number().min(0).max(1).optional(),
+                    green: z.number().min(0).max(1).optional(),
+                    blue: z.number().min(0).max(1).optional(),
+                    alpha: z.number().min(0).max(1).optional(),
+                })
+                .describe('Background color (RGBA 0-1)'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            const requests = args.pageObjectIds.map((pageObjectId) => ({
+                updatePageProperties: {
+                    objectId: pageObjectId,
+                    pageProperties: {
+                        pageBackgroundFill: {
+                            solidFill: {
+                                color: {
+                                    rgbColor: {
+                                        red: args.backgroundColor.red || 0,
+                                        green: args.backgroundColor.green || 0,
+                                        blue: args.backgroundColor.blue || 0,
+                                    },
+                                },
+                                alpha: args.backgroundColor.alpha ?? 1,
+                            },
+                        },
+                    },
+                    fields: 'pageBackgroundFill',
+                },
+            }));
+
+            try {
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: { requests },
+                });
+                return JSON.stringify({ success: true, message: `Set background for ${args.pageObjectIds.length} slide(s)` });
+            } catch (error) {
+                log.error(`Error setting background: ${error.message || error}`);
+                throw new UserError(`Failed to set background: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/speakerNotes.js

@@ -0,0 +1,102 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    // --- Get speaker notes ---
+    server.addTool({
+        name: 'getSpeakerNotes',
+        description: 'Get the speaker notes from a specific slide in a Google Slides presentation.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            slideIndex: z.number().min(0).describe('Slide index (0-based)'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            try {
+                const presentation = await slidesApi.presentations.get({ presentationId: args.presentationId });
+                const allSlides = presentation.data.slides || [];
+
+                if (args.slideIndex >= allSlides.length) {
+                    throw new UserError(`Slide index ${args.slideIndex} out of range (presentation has ${allSlides.length} slides)`);
+                }
+
+                const slide = allSlides[args.slideIndex];
+                const notesObjectId = slide.slideProperties?.notesPage?.notesProperties?.speakerNotesObjectId;
+
+                if (!notesObjectId) {
+                    return JSON.stringify({ slideIndex: args.slideIndex, notes: '' });
+                }
+
+                const notesPage = slide.slideProperties?.notesPage;
+                const notesElement = notesPage?.pageElements?.find((el) => el.objectId === notesObjectId);
+
+                let notesText = '';
+                if (notesElement?.shape?.text?.textElements) {
+                    for (const te of notesElement.shape.text.textElements) {
+                        if (te.textRun?.content) notesText += te.textRun.content;
+                    }
+                }
+
+                return JSON.stringify({ slideIndex: args.slideIndex, notes: notesText.trim() });
+            } catch (error) {
+                if (error instanceof UserError) throw error;
+                log.error(`Error getting speaker notes: ${error.message || error}`);
+                throw new UserError(`Failed to get speaker notes: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+
+    // --- Update speaker notes ---
+    server.addTool({
+        name: 'updateSpeakerNotes',
+        description: 'Update the speaker notes for a specific slide in a Google Slides presentation.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            slideIndex: z.number().min(0).describe('Slide index (0-based)'),
+            notes: z.string().describe('Speaker notes content'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            try {
+                const presentation = await slidesApi.presentations.get({ presentationId: args.presentationId });
+                const allSlides = presentation.data.slides || [];
+
+                if (args.slideIndex >= allSlides.length) {
+                    throw new UserError(`Slide index ${args.slideIndex} out of range (presentation has ${allSlides.length} slides)`);
+                }
+
+                const slide = allSlides[args.slideIndex];
+                const notesObjectId = slide.slideProperties?.notesPage?.notesProperties?.speakerNotesObjectId;
+
+                if (!notesObjectId) {
+                    throw new UserError('This slide does not have a speaker notes object.');
+                }
+
+                // Check if there's existing text to delete first
+                const notesPage = slide.slideProperties?.notesPage;
+                const notesElement = notesPage?.pageElements?.find((el) => el.objectId === notesObjectId);
+                const hasExistingText = notesElement?.shape?.text?.textElements?.some((el) => el.textRun?.content);
+
+                const requests = [];
+                if (hasExistingText) {
+                    requests.push({ deleteText: { objectId: notesObjectId, textRange: { type: 'ALL' } } });
+                }
+                requests.push({ insertText: { objectId: notesObjectId, text: args.notes, insertionIndex: 0 } });
+
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: { requests },
+                });
+
+                return JSON.stringify({ success: true, message: `Updated speaker notes for slide ${args.slideIndex}` });
+            } catch (error) {
+                if (error instanceof UserError) throw error;
+                log.error(`Error updating speaker notes: ${error.message || error}`);
+                throw new UserError(`Failed to update speaker notes: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/styleShape.js

@@ -0,0 +1,111 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'styleSlidesShape',
+        description:
+            'Style a shape in Google Slides: set background color, outline color/weight/dash style.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            objectId: z.string().describe('Shape object ID'),
+            backgroundColor: z
+                .object({
+                    red: z.number().min(0).max(1).optional(),
+                    green: z.number().min(0).max(1).optional(),
+                    blue: z.number().min(0).max(1).optional(),
+                    alpha: z.number().min(0).max(1).optional(),
+                })
+                .optional()
+                .describe('Fill color (RGBA 0-1)'),
+            outlineColor: z
+                .object({
+                    red: z.number().min(0).max(1).optional(),
+                    green: z.number().min(0).max(1).optional(),
+                    blue: z.number().min(0).max(1).optional(),
+                })
+                .optional()
+                .describe('Outline color (RGB 0-1)'),
+            outlineWeight: z.number().optional().describe('Outline thickness in points'),
+            outlineDashStyle: z
+                .enum(['SOLID', 'DOT', 'DASH', 'DASH_DOT', 'LONG_DASH', 'LONG_DASH_DOT'])
+                .optional()
+                .describe('Outline dash style'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+            const shapeProperties = {};
+            const fields = [];
+
+            if (args.backgroundColor) {
+                shapeProperties.shapeBackgroundFill = {
+                    solidFill: {
+                        color: {
+                            rgbColor: {
+                                red: args.backgroundColor.red || 0,
+                                green: args.backgroundColor.green || 0,
+                                blue: args.backgroundColor.blue || 0,
+                            },
+                        },
+                        alpha: args.backgroundColor.alpha ?? 1,
+                    },
+                };
+                fields.push('shapeBackgroundFill');
+            }
+
+            const outline = {};
+            let hasOutline = false;
+
+            if (args.outlineColor) {
+                outline.outlineFill = {
+                    solidFill: {
+                        color: {
+                            rgbColor: {
+                                red: args.outlineColor.red || 0,
+                                green: args.outlineColor.green || 0,
+                                blue: args.outlineColor.blue || 0,
+                            },
+                        },
+                    },
+                };
+                hasOutline = true;
+            }
+            if (args.outlineWeight !== undefined) {
+                outline.weight = { magnitude: args.outlineWeight, unit: 'PT' };
+                hasOutline = true;
+            }
+            if (args.outlineDashStyle) {
+                outline.dashStyle = args.outlineDashStyle;
+                hasOutline = true;
+            }
+            if (hasOutline) {
+                shapeProperties.outline = outline;
+                fields.push('outline');
+            }
+
+            if (fields.length === 0) throw new UserError('No styling options specified');
+
+            try {
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: {
+                        requests: [
+                            {
+                                updateShapeProperties: {
+                                    objectId: args.objectId,
+                                    shapeProperties,
+                                    fields: fields.join(','),
+                                },
+                            },
+                        ],
+                    },
+                });
+                return JSON.stringify({ success: true, message: `Applied styling to shape ${args.objectId}` });
+            } catch (error) {
+                log.error(`Error styling shape: ${error.message || error}`);
+                throw new UserError(`Failed to style shape: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/updatePresentation.js

@@ -0,0 +1,128 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'updatePresentation',
+        description:
+            'Replace all slides in an existing Google Slides presentation with new content. Deletes existing slides and creates new ones with the provided title/content pairs.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            slides: z
+                .array(
+                    z.object({
+                        title: z.string().describe('Slide title'),
+                        content: z.string().describe('Slide body content'),
+                    }),
+                )
+                .min(1)
+                .describe('Array of slide objects to replace existing slides'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+            log.info(`Updating presentation: ${args.presentationId}`);
+
+            try {
+                const currentPresentation = await slidesApi.presentations.get({
+                    presentationId: args.presentationId,
+                });
+
+                if (!currentPresentation.data.slides) {
+                    throw new UserError('No slides found in presentation');
+                }
+
+                // Delete all slides except the first, then clear and rewrite the first
+                const slideIdsToDelete = currentPresentation.data.slides
+                    .slice(1)
+                    .map((s) => s.objectId)
+                    .filter(Boolean);
+
+                const requests = [];
+
+                // Delete extra slides
+                for (const id of slideIdsToDelete) {
+                    requests.push({ deleteObject: { objectId: id } });
+                }
+
+                // Clear text from the first slide's text elements
+                const firstSlide = currentPresentation.data.slides[0];
+                if (firstSlide?.pageElements) {
+                    for (const el of firstSlide.pageElements) {
+                        if (el.objectId && el.shape?.text) {
+                            requests.push({ deleteText: { objectId: el.objectId, textRange: { type: 'ALL' } } });
+                        }
+                    }
+                }
+
+                // Insert new content into first slide
+                const firstContent = args.slides[0];
+                if (firstSlide?.pageElements) {
+                    let titleId, bodyId;
+                    for (const el of firstSlide.pageElements) {
+                        const pt = el.shape?.placeholder?.type;
+                        if (pt === 'TITLE' || pt === 'CENTERED_TITLE') titleId = el.objectId;
+                        else if (pt === 'BODY' || pt === 'SUBTITLE') bodyId = el.objectId;
+                    }
+                    if (titleId) requests.push({ insertText: { objectId: titleId, text: firstContent.title, insertionIndex: 0 } });
+                    if (bodyId) requests.push({ insertText: { objectId: bodyId, text: firstContent.content, insertionIndex: 0 } });
+                }
+
+                // Create additional slides
+                for (let i = 1; i < args.slides.length; i++) {
+                    requests.push({
+                        createSlide: {
+                            objectId: `slide_${Date.now()}_${i}`,
+                            slideLayoutReference: { predefinedLayout: 'TITLE_AND_BODY' },
+                        },
+                    });
+                }
+
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: { requests },
+                });
+
+                // Populate new slides (index 1+)
+                if (args.slides.length > 1) {
+                    const updated = await slidesApi.presentations.get({ presentationId: args.presentationId });
+                    const contentRequests = [];
+                    for (let i = 1; i < args.slides.length && updated.data.slides; i++) {
+                        const slide = args.slides[i];
+                        const pageSlide = updated.data.slides[i];
+                        if (!pageSlide?.pageElements) continue;
+                        for (const el of pageSlide.pageElements) {
+                            if (!el.objectId) continue;
+                            const pt = el.shape?.placeholder?.type;
+                            if (pt === 'TITLE' || pt === 'CENTERED_TITLE') {
+                                contentRequests.push({ insertText: { objectId: el.objectId, text: slide.title, insertionIndex: 0 } });
+                            } else if (pt === 'BODY' || pt === 'SUBTITLE') {
+                                contentRequests.push({ insertText: { objectId: el.objectId, text: slide.content, insertionIndex: 0 } });
+                            }
+                        }
+                    }
+                    if (contentRequests.length > 0) {
+                        await slidesApi.presentations.batchUpdate({
+                            presentationId: args.presentationId,
+                            requestBody: { requests: contentRequests },
+                        });
+                    }
+                }
+
+                return JSON.stringify(
+                    {
+                        presentationId: args.presentationId,
+                        slidesUpdated: args.slides.length,
+                        link: `https://docs.google.com/presentation/d/${args.presentationId}`,
+                    },
+                    null,
+                    2,
+                );
+            } catch (error) {
+                if (error instanceof UserError) throw error;
+                log.error(`Error updating presentation: ${error.message || error}`);
+                throw new UserError(`Failed to update presentation: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "google-tools-mcp",
-  "version": "1.1.1",
-  "description": "Combined Google Workspace MCP server (Drive, Docs, Sheets, Gmail) with lazy-loaded tool categories",
+  "version": "1.1.3",
+  "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": {
     "google-tools-mcp": "dist/index.js"
@@ -11,16 +11,55 @@
   ],
   "keywords": [
     "mcp",
+    "mcp-server",
+    "model-context-protocol",
     "google",
+    "google-workspace",
+    "google-drive",
+    "google-docs",
+    "google-sheets",
+    "google-calendar",
+    "google-forms",
     "gdrive",
     "gmail",
+    "email",
+    "send-email",
+    "read-email",
+    "email-drafts",
+    "email-labels",
+    "email-filters",
     "sheets",
-    "docs"
+    "spreadsheet",
+    "docs",
+    "calendar",
+    "forms",
+    "drive",
+    "pdf",
+    "read-pdf",
+    "word",
+    "docx",
+    "read-docx",
+    "file-reader",
+    "oauth",
+    "easy-auth",
+    "browser-auth",
+    "claude",
+    "ai",
+    "llm",
+    "ai-tools"
   ],
   "scripts": {
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
     "test:ci": "node --experimental-vm-modules node_modules/jest/bin/jest.js --ci --coverage"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/karthikcsq/google-tools-mcp.git"
+  },
+  "homepage": "https://github.com/karthikcsq/google-tools-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/karthikcsq/google-tools-mcp/issues"
+  },
   "license": "MIT",
   "dependencies": {
     "fastmcp": "^3.24.0",