google-tools-mcp 1.2.11 → 2.0.0

package/dist/tools/slides/index.js

@@ -1,33 +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);
-}
+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

@@ -1,41 +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'}`);
-            }
-        },
-    });
-}
+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

@@ -1,46 +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'}`);
-            }
-        },
-    });
-}
+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

@@ -1,58 +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'}`);
-            }
-        },
-    });
-}
+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

@@ -1,102 +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'}`);
-            }
-        },
-    });
-}
+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'}`);
+            }
+        },
+    });
+}