google-tools-mcp 1.2.11 → 2.0.0

package/dist/tools/slides/createPresentation.js

@@ -1,104 +1,104 @@
-import { UserError } from 'fastmcp';
-import { z } from 'zod';
-import { getSlidesClient, getDriveClient } from '../../clients.js';
-
-export function register(server) {
-    server.addTool({
-        name: 'createPresentation',
-        description:
-            'Create a new Google Slides presentation with initial slides. Each slide has a title and content body using the TITLE_AND_BODY layout.',
-        parameters: z.object({
-            name: z.string().describe('Presentation name'),
-            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 with title and content'),
-            parentFolderId: z.string().optional().describe('Parent Drive folder ID (defaults to root)'),
-        }),
-        execute: async (args, { log }) => {
-            const slides = await getSlidesClient();
-            const drive = await getDriveClient();
-            log.info(`Creating presentation: ${args.name}`);
-
-            try {
-                // Create the presentation
-                const presentation = await slides.presentations.create({
-                    requestBody: { title: args.name },
-                });
-                const presentationId = presentation.data.presentationId;
-
-                // Move to folder if specified
-                if (args.parentFolderId) {
-                    await drive.files.update({
-                        fileId: presentationId,
-                        addParents: args.parentFolderId,
-                        removeParents: 'root',
-                        supportsAllDrives: true,
-                    });
-                }
-
-                // Create each slide and populate content
-                for (const slide of args.slides) {
-                    const slideObjectId = `slide_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-                    await slides.presentations.batchUpdate({
-                        presentationId,
-                        requestBody: {
-                            requests: [
-                                {
-                                    createSlide: {
-                                        objectId: slideObjectId,
-                                        slideLayoutReference: { predefinedLayout: 'TITLE_AND_BODY' },
-                                    },
-                                },
-                            ],
-                        },
-                    });
-
-                    // Get the slide to find placeholder IDs
-                    const slidePage = await slides.presentations.pages.get({
-                        presentationId,
-                        pageObjectId: slideObjectId,
-                    });
-
-                    let titleId = '';
-                    let bodyId = '';
-                    for (const el of slidePage.data.pageElements || []) {
-                        if (el.shape?.placeholder?.type === 'TITLE') titleId = el.objectId;
-                        else if (el.shape?.placeholder?.type === 'BODY') bodyId = el.objectId;
-                    }
-
-                    const insertRequests = [];
-                    if (titleId) insertRequests.push({ insertText: { objectId: titleId, text: slide.title, insertionIndex: 0 } });
-                    if (bodyId) insertRequests.push({ insertText: { objectId: bodyId, text: slide.content, insertionIndex: 0 } });
-
-                    if (insertRequests.length > 0) {
-                        await slides.presentations.batchUpdate({
-                            presentationId,
-                            requestBody: { requests: insertRequests },
-                        });
-                    }
-                }
-
-                return JSON.stringify(
-                    {
-                        presentationId,
-                        title: args.name,
-                        link: `https://docs.google.com/presentation/d/${presentationId}`,
-                        slidesCreated: args.slides.length,
-                    },
-                    null,
-                    2,
-                );
-            } catch (error) {
-                log.error(`Error creating presentation: ${error.message || error}`);
-                if (error.code === 401) throw new UserError('Authentication failed. Try logging out and re-authenticating.');
-                throw new UserError(`Failed to create presentation: ${error.message || 'Unknown error'}`);
-            }
-        },
-    });
-}
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient, getDriveClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'createPresentation',
+        description:
+            'Create a new Google Slides presentation with initial slides. Each slide has a title and content body using the TITLE_AND_BODY layout.',
+        parameters: z.object({
+            name: z.string().describe('Presentation name'),
+            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 with title and content'),
+            parentFolderId: z.string().optional().describe('Parent Drive folder ID (defaults to root)'),
+        }),
+        execute: async (args, { log }) => {
+            const slides = await getSlidesClient();
+            const drive = await getDriveClient();
+            log.info(`Creating presentation: ${args.name}`);
+
+            try {
+                // Create the presentation
+                const presentation = await slides.presentations.create({
+                    requestBody: { title: args.name },
+                });
+                const presentationId = presentation.data.presentationId;
+
+                // Move to folder if specified
+                if (args.parentFolderId) {
+                    await drive.files.update({
+                        fileId: presentationId,
+                        addParents: args.parentFolderId,
+                        removeParents: 'root',
+                        supportsAllDrives: true,
+                    });
+                }
+
+                // Create each slide and populate content
+                for (const slide of args.slides) {
+                    const slideObjectId = `slide_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+                    await slides.presentations.batchUpdate({
+                        presentationId,
+                        requestBody: {
+                            requests: [
+                                {
+                                    createSlide: {
+                                        objectId: slideObjectId,
+                                        slideLayoutReference: { predefinedLayout: 'TITLE_AND_BODY' },
+                                    },
+                                },
+                            ],
+                        },
+                    });
+
+                    // Get the slide to find placeholder IDs
+                    const slidePage = await slides.presentations.pages.get({
+                        presentationId,
+                        pageObjectId: slideObjectId,
+                    });
+
+                    let titleId = '';
+                    let bodyId = '';
+                    for (const el of slidePage.data.pageElements || []) {
+                        if (el.shape?.placeholder?.type === 'TITLE') titleId = el.objectId;
+                        else if (el.shape?.placeholder?.type === 'BODY') bodyId = el.objectId;
+                    }
+
+                    const insertRequests = [];
+                    if (titleId) insertRequests.push({ insertText: { objectId: titleId, text: slide.title, insertionIndex: 0 } });
+                    if (bodyId) insertRequests.push({ insertText: { objectId: bodyId, text: slide.content, insertionIndex: 0 } });
+
+                    if (insertRequests.length > 0) {
+                        await slides.presentations.batchUpdate({
+                            presentationId,
+                            requestBody: { requests: insertRequests },
+                        });
+                    }
+                }
+
+                return JSON.stringify(
+                    {
+                        presentationId,
+                        title: args.name,
+                        link: `https://docs.google.com/presentation/d/${presentationId}`,
+                        slidesCreated: args.slides.length,
+                    },
+                    null,
+                    2,
+                );
+            } catch (error) {
+                log.error(`Error creating presentation: ${error.message || error}`);
+                if (error.code === 401) throw new UserError('Authentication failed. Try logging out and re-authenticating.');
+                throw new UserError(`Failed to create presentation: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/createShape.js

@@ -1,92 +1,92 @@
-import { UserError } from 'fastmcp';
-import { z } from 'zod';
-import { getSlidesClient } from '../../clients.js';
-
-export function register(server) {
-    server.addTool({
-        name: 'createSlidesShape',
-        description:
-            'Create a shape on a slide in Google Slides. Position and size are in EMU (914400 EMU = 1 inch).',
-        parameters: z.object({
-            presentationId: z.string().describe('Presentation ID'),
-            pageObjectId: z.string().describe('Slide page object ID'),
-            shapeType: z
-                .enum(['RECTANGLE', 'ELLIPSE', 'DIAMOND', 'TRIANGLE', 'STAR', 'ROUND_RECTANGLE', 'ARROW'])
-                .describe('Shape type'),
-            x: z.number().describe('X position in EMU'),
-            y: z.number().describe('Y position in EMU'),
-            width: z.number().describe('Width in EMU'),
-            height: z.number().describe('Height in EMU'),
-            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)'),
-        }),
-        execute: async (args, { log }) => {
-            const slidesApi = await getSlidesClient();
-            const elementId = `shape_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-
-            const requests = [
-                {
-                    createShape: {
-                        objectId: elementId,
-                        shapeType: args.shapeType,
-                        elementProperties: {
-                            pageObjectId: args.pageObjectId,
-                            size: {
-                                width: { magnitude: args.width, unit: 'EMU' },
-                                height: { magnitude: args.height, unit: 'EMU' },
-                            },
-                            transform: {
-                                scaleX: 1,
-                                scaleY: 1,
-                                translateX: args.x,
-                                translateY: args.y,
-                                unit: 'EMU',
-                            },
-                        },
-                    },
-                },
-            ];
-
-            if (args.backgroundColor) {
-                requests.push({
-                    updateShapeProperties: {
-                        objectId: elementId,
-                        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: 'shapeBackgroundFill',
-                    },
-                });
-            }
-
-            try {
-                await slidesApi.presentations.batchUpdate({
-                    presentationId: args.presentationId,
-                    requestBody: { requests },
-                });
-                return JSON.stringify({ success: true, objectId: elementId, message: `Created ${args.shapeType} shape: ${elementId}` });
-            } catch (error) {
-                log.error(`Error creating shape: ${error.message || error}`);
-                throw new UserError(`Failed to create shape: ${error.message || 'Unknown error'}`);
-            }
-        },
-    });
-}
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'createSlidesShape',
+        description:
+            'Create a shape on a slide in Google Slides. Position and size are in EMU (914400 EMU = 1 inch).',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            pageObjectId: z.string().describe('Slide page object ID'),
+            shapeType: z
+                .enum(['RECTANGLE', 'ELLIPSE', 'DIAMOND', 'TRIANGLE', 'STAR', 'ROUND_RECTANGLE', 'ARROW'])
+                .describe('Shape type'),
+            x: z.number().describe('X position in EMU'),
+            y: z.number().describe('Y position in EMU'),
+            width: z.number().describe('Width in EMU'),
+            height: z.number().describe('Height in EMU'),
+            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)'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+            const elementId = `shape_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+
+            const requests = [
+                {
+                    createShape: {
+                        objectId: elementId,
+                        shapeType: args.shapeType,
+                        elementProperties: {
+                            pageObjectId: args.pageObjectId,
+                            size: {
+                                width: { magnitude: args.width, unit: 'EMU' },
+                                height: { magnitude: args.height, unit: 'EMU' },
+                            },
+                            transform: {
+                                scaleX: 1,
+                                scaleY: 1,
+                                translateX: args.x,
+                                translateY: args.y,
+                                unit: 'EMU',
+                            },
+                        },
+                    },
+                },
+            ];
+
+            if (args.backgroundColor) {
+                requests.push({
+                    updateShapeProperties: {
+                        objectId: elementId,
+                        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: 'shapeBackgroundFill',
+                    },
+                });
+            }
+
+            try {
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: { requests },
+                });
+                return JSON.stringify({ success: true, objectId: elementId, message: `Created ${args.shapeType} shape: ${elementId}` });
+            } catch (error) {
+                log.error(`Error creating shape: ${error.message || error}`);
+                throw new UserError(`Failed to create shape: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/createTextBox.js

@@ -1,82 +1,82 @@
-import { UserError } from 'fastmcp';
-import { z } from 'zod';
-import { getSlidesClient } from '../../clients.js';
-
-export function register(server) {
-    server.addTool({
-        name: 'createSlidesTextBox',
-        description:
-            'Create a text box on a slide in Google Slides. Position and size are in EMU (English Metric Units: 914400 EMU = 1 inch).',
-        parameters: z.object({
-            presentationId: z.string().describe('Presentation ID'),
-            pageObjectId: z.string().describe('Slide page object ID'),
-            text: z.string().describe('Text content'),
-            x: z.number().describe('X position in EMU'),
-            y: z.number().describe('Y position in EMU'),
-            width: z.number().describe('Width in EMU'),
-            height: z.number().describe('Height in EMU'),
-            fontSize: z.number().optional().describe('Font size in points'),
-            bold: z.boolean().optional().describe('Make text bold'),
-            italic: z.boolean().optional().describe('Make text italic'),
-        }),
-        execute: async (args, { log }) => {
-            const slidesApi = await getSlidesClient();
-            const elementId = `textBox_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-
-            const requests = [
-                {
-                    createShape: {
-                        objectId: elementId,
-                        shapeType: 'TEXT_BOX',
-                        elementProperties: {
-                            pageObjectId: args.pageObjectId,
-                            size: {
-                                width: { magnitude: args.width, unit: 'EMU' },
-                                height: { magnitude: args.height, unit: 'EMU' },
-                            },
-                            transform: {
-                                scaleX: 1,
-                                scaleY: 1,
-                                translateX: args.x,
-                                translateY: args.y,
-                                unit: 'EMU',
-                            },
-                        },
-                    },
-                },
-                {
-                    insertText: { objectId: elementId, text: args.text, insertionIndex: 0 },
-                },
-            ];
-
-            // Optional formatting
-            const textStyle = {};
-            const fields = [];
-            if (args.fontSize) { textStyle.fontSize = { magnitude: args.fontSize, unit: 'PT' }; fields.push('fontSize'); }
-            if (args.bold !== undefined) { textStyle.bold = args.bold; fields.push('bold'); }
-            if (args.italic !== undefined) { textStyle.italic = args.italic; fields.push('italic'); }
-
-            if (fields.length > 0) {
-                requests.push({
-                    updateTextStyle: {
-                        objectId: elementId,
-                        style: textStyle,
-                        fields: fields.join(','),
-                        textRange: { type: 'ALL' },
-                    },
-                });
-            }
-
-            try {
-                await slidesApi.presentations.batchUpdate({
-                    presentationId: args.presentationId,
-                    requestBody: { requests },
-                });
-                return JSON.stringify({ success: true, objectId: elementId, message: `Created text box: ${elementId}` });
-            } catch (error) {
-                log.error(`Error creating text box: ${error.message || error}`);
-                throw new UserError(`Failed to create text box: ${error.message || 'Unknown error'}`);
-            }
-        },
-    });
-}
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'createSlidesTextBox',
+        description:
+            'Create a text box on a slide in Google Slides. Position and size are in EMU (English Metric Units: 914400 EMU = 1 inch).',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            pageObjectId: z.string().describe('Slide page object ID'),
+            text: z.string().describe('Text content'),
+            x: z.number().describe('X position in EMU'),
+            y: z.number().describe('Y position in EMU'),
+            width: z.number().describe('Width in EMU'),
+            height: z.number().describe('Height in EMU'),
+            fontSize: z.number().optional().describe('Font size in points'),
+            bold: z.boolean().optional().describe('Make text bold'),
+            italic: z.boolean().optional().describe('Make text italic'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+            const elementId = `textBox_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+
+            const requests = [
+                {
+                    createShape: {
+                        objectId: elementId,
+                        shapeType: 'TEXT_BOX',
+                        elementProperties: {
+                            pageObjectId: args.pageObjectId,
+                            size: {
+                                width: { magnitude: args.width, unit: 'EMU' },
+                                height: { magnitude: args.height, unit: 'EMU' },
+                            },
+                            transform: {
+                                scaleX: 1,
+                                scaleY: 1,
+                                translateX: args.x,
+                                translateY: args.y,
+                                unit: 'EMU',
+                            },
+                        },
+                    },
+                },
+                {
+                    insertText: { objectId: elementId, text: args.text, insertionIndex: 0 },
+                },
+            ];
+
+            // Optional formatting
+            const textStyle = {};
+            const fields = [];
+            if (args.fontSize) { textStyle.fontSize = { magnitude: args.fontSize, unit: 'PT' }; fields.push('fontSize'); }
+            if (args.bold !== undefined) { textStyle.bold = args.bold; fields.push('bold'); }
+            if (args.italic !== undefined) { textStyle.italic = args.italic; fields.push('italic'); }
+
+            if (fields.length > 0) {
+                requests.push({
+                    updateTextStyle: {
+                        objectId: elementId,
+                        style: textStyle,
+                        fields: fields.join(','),
+                        textRange: { type: 'ALL' },
+                    },
+                });
+            }
+
+            try {
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: { requests },
+                });
+                return JSON.stringify({ success: true, objectId: elementId, message: `Created text box: ${elementId}` });
+            } catch (error) {
+                log.error(`Error creating text box: ${error.message || error}`);
+                throw new UserError(`Failed to create text box: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/deleteSlide.js

@@ -1,30 +1,30 @@
-import { UserError } from 'fastmcp';
-import { z } from 'zod';
-import { getSlidesClient } from '../../clients.js';
-
-export function register(server) {
-    server.addTool({
-        name: 'deleteSlide',
-        description: 'Delete a slide from a Google Slides presentation.',
-        parameters: z.object({
-            presentationId: z.string().describe('Presentation ID'),
-            slideObjectId: z.string().describe('Object ID of the slide to delete'),
-        }),
-        execute: async (args, { log }) => {
-            const slidesApi = await getSlidesClient();
-
-            try {
-                await slidesApi.presentations.batchUpdate({
-                    presentationId: args.presentationId,
-                    requestBody: {
-                        requests: [{ deleteObject: { objectId: args.slideObjectId } }],
-                    },
-                });
-                return JSON.stringify({ success: true, message: `Deleted slide ${args.slideObjectId}` });
-            } catch (error) {
-                log.error(`Error deleting slide: ${error.message || error}`);
-                throw new UserError(`Failed to delete slide: ${error.message || 'Unknown error'}`);
-            }
-        },
-    });
-}
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'deleteSlide',
+        description: 'Delete a slide from a Google Slides presentation.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            slideObjectId: z.string().describe('Object ID of the slide to delete'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            try {
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: {
+                        requests: [{ deleteObject: { objectId: args.slideObjectId } }],
+                    },
+                });
+                return JSON.stringify({ success: true, message: `Deleted slide ${args.slideObjectId}` });
+            } catch (error) {
+                log.error(`Error deleting slide: ${error.message || error}`);
+                throw new UserError(`Failed to delete slide: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}