@alanse/mcp-server-google-workspace 0.2.1 → 1.0.0

package/dist/tools/docs/content/gdocs_update_text.js

@@ -0,0 +1,78 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+import { Validator } from "../../../lib/validation.js";
+export const schema = {
+    name: "gdocs_update_text",
+    description: "Update (replace) text in a specific range in a Google Document. Indices are 1-based.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            startIndex: {
+                type: "number",
+                description: "Start position of text to replace (1-based, inclusive)",
+            },
+            endIndex: {
+                type: "number",
+                description: "End position of text to replace (1-based, exclusive)",
+            },
+            text: {
+                type: "string",
+                description: "New text to replace the range with",
+            },
+        },
+        required: ["documentId", "startIndex", "endIndex", "text"],
+    },
+};
+export async function updateText(args) {
+    try {
+        // Validate inputs
+        if (!Validator.validateRange(args.startIndex, args.endIndex)) {
+            throw new Error("Invalid range: startIndex must be less than endIndex and both must be positive");
+        }
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        // First delete the range, then insert new text
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        deleteContentRange: {
+                            range: {
+                                startIndex: args.startIndex,
+                                endIndex: args.endIndex,
+                            },
+                        },
+                    },
+                    {
+                        insertText: {
+                            text: args.text,
+                            location: {
+                                index: args.startIndex,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            updatedRange: {
+                startIndex: args.startIndex,
+                endIndex: args.startIndex + args.text.length,
+            },
+            newText: args.text,
+            replacedLength: args.endIndex - args.startIndex,
+        }, "Text updated successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/elements/gdocs_batch_update.js

@@ -0,0 +1,108 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+export const schema = {
+    name: "gdocs_batch_update",
+    description: "Execute multiple update operations on a Google Document in a single API call. Requests are executed in order.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            requests: {
+                type: "array",
+                description: "Array of update requests to execute",
+                items: {
+                    type: "object",
+                    properties: {
+                        type: {
+                            type: "string",
+                            description: "Type of operation",
+                            enum: [
+                                "insertText",
+                                "deleteContentRange",
+                                "updateTextStyle",
+                                "updateParagraphStyle",
+                                "createParagraphBullets",
+                                "insertTable",
+                                "insertInlineImage",
+                                "insertPageBreak",
+                                "createHeader",
+                                "createFooter",
+                            ],
+                        },
+                        params: {
+                            type: "object",
+                            description: "Parameters for the operation (structure depends on type)",
+                        },
+                    },
+                    required: ["type", "params"],
+                },
+            },
+        },
+        required: ["documentId", "requests"],
+    },
+};
+export async function batchUpdate(args) {
+    try {
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        // Convert our simplified request format to Google Docs API format
+        const requests = args.requests.map((req) => {
+            const apiRequest = {};
+            switch (req.type) {
+                case "insertText":
+                    apiRequest.insertText = req.params;
+                    break;
+                case "deleteContentRange":
+                    apiRequest.deleteContentRange = req.params;
+                    break;
+                case "updateTextStyle":
+                    apiRequest.updateTextStyle = req.params;
+                    break;
+                case "updateParagraphStyle":
+                    apiRequest.updateParagraphStyle = req.params;
+                    break;
+                case "createParagraphBullets":
+                    apiRequest.createParagraphBullets = req.params;
+                    break;
+                case "insertTable":
+                    apiRequest.insertTable = req.params;
+                    break;
+                case "insertInlineImage":
+                    apiRequest.insertInlineImage = req.params;
+                    break;
+                case "insertPageBreak":
+                    apiRequest.insertPageBreak = req.params;
+                    break;
+                case "createHeader":
+                    apiRequest.createHeader = req.params;
+                    break;
+                case "createFooter":
+                    apiRequest.createFooter = req.params;
+                    break;
+                default:
+                    throw new Error(`Unknown request type: ${req.type}`);
+            }
+            return apiRequest;
+        });
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests,
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            operationsExecuted: args.requests.length,
+            requestTypes: args.requests.map((r) => r.type),
+        }, `Successfully executed ${args.requests.length} operation(s)`);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/elements/gdocs_create_table.js

@@ -0,0 +1,73 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+import { Validator } from "../../../lib/validation.js";
+export const schema = {
+    name: "gdocs_create_table",
+    description: "Create a table with specified rows and columns in a Google Document.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            rows: {
+                type: "number",
+                description: "Number of rows in the table",
+            },
+            columns: {
+                type: "number",
+                description: "Number of columns in the table",
+            },
+            index: {
+                type: "number",
+                description: "Position to insert table (1-based)",
+            },
+        },
+        required: ["documentId", "rows", "columns", "index"],
+    },
+};
+export async function createTable(args) {
+    try {
+        // Validate inputs
+        if (!Validator.validateIndex(args.index)) {
+            throw new Error("Index must be a positive integer");
+        }
+        if (!Validator.validateIndex(args.rows) || args.rows < 1 || args.rows > 20) {
+            throw new Error("Rows must be between 1 and 20");
+        }
+        if (!Validator.validateIndex(args.columns) || args.columns < 1 || args.columns > 20) {
+            throw new Error("Columns must be between 1 and 20");
+        }
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        insertTable: {
+                            rows: args.rows,
+                            columns: args.columns,
+                            location: {
+                                index: args.index,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            rows: args.rows,
+            columns: args.columns,
+            insertedAt: args.index,
+        }, `Table created successfully (${args.rows}x${args.columns})`);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/elements/gdocs_export.js

@@ -0,0 +1,62 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+export const schema = {
+    name: "gdocs_export",
+    description: "Export a Google Document to different formats (PDF, DOCX, Plain Text, HTML, EPUB).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            mimeType: {
+                type: "string",
+                description: "Export format",
+                enum: [
+                    "application/pdf",
+                    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                    "text/plain",
+                    "text/html",
+                    "application/epub+zip",
+                ],
+            },
+        },
+        required: ["documentId", "mimeType"],
+    },
+};
+export async function exportDocument(args) {
+    try {
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const drive = google.drive("v3");
+        // Export the document
+        const response = await drive.files.export({
+            fileId: documentId,
+            mimeType: args.mimeType,
+        }, { responseType: "arraybuffer" });
+        // Get file size
+        const fileSize = Buffer.byteLength(response.data);
+        // Map MIME type to file extension
+        const extensionMap = {
+            "application/pdf": "pdf",
+            "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+            "text/plain": "txt",
+            "text/html": "html",
+            "application/epub+zip": "epub",
+        };
+        const extension = extensionMap[args.mimeType];
+        return ResponseFormatter.success({
+            documentId,
+            mimeType: args.mimeType,
+            extension,
+            fileSize,
+            note: "Document exported successfully. The exported file data is available in the API response but not shown here for brevity.",
+        }, "Document exported successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/elements/gdocs_insert_image.js

@@ -0,0 +1,96 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+import { Validator } from "../../../lib/validation.js";
+export const schema = {
+    name: "gdocs_insert_image",
+    description: "Insert an image from a URL into a Google Document at a specific position.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            imageUrl: {
+                type: "string",
+                description: "URL of the image to insert (must be publicly accessible)",
+            },
+            index: {
+                type: "number",
+                description: "Position to insert image (1-based)",
+            },
+            width: {
+                type: "number",
+                description: "Image width in points (optional)",
+            },
+            height: {
+                type: "number",
+                description: "Image height in points (optional)",
+            },
+        },
+        required: ["documentId", "imageUrl", "index"],
+    },
+};
+export async function insertImage(args) {
+    try {
+        // Validate inputs
+        if (!Validator.validateIndex(args.index)) {
+            throw new Error("Index must be a positive integer");
+        }
+        if (!Validator.validateUrl(args.imageUrl)) {
+            throw new Error("Invalid image URL");
+        }
+        if (args.width && !Validator.validatePositiveNumber(args.width)) {
+            throw new Error("Width must be a positive number");
+        }
+        if (args.height && !Validator.validatePositiveNumber(args.height)) {
+            throw new Error("Height must be a positive number");
+        }
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        // Build image properties
+        const imageProperties = {
+            contentUri: args.imageUrl,
+        };
+        if (args.width || args.height) {
+            imageProperties.sourceUri = args.imageUrl;
+        }
+        // Build object size if dimensions specified
+        let objectSize;
+        if (args.width || args.height) {
+            objectSize = {
+                width: args.width ? { magnitude: args.width, unit: "PT" } : undefined,
+                height: args.height ? { magnitude: args.height, unit: "PT" } : undefined,
+            };
+        }
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        insertInlineImage: {
+                            uri: args.imageUrl,
+                            location: {
+                                index: args.index,
+                            },
+                            objectSize,
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            imageUrl: args.imageUrl,
+            insertedAt: args.index,
+            width: args.width,
+            height: args.height,
+        }, "Image inserted successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/elements/gdocs_insert_link.js

@@ -0,0 +1,77 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+import { Validator } from "../../../lib/validation.js";
+export const schema = {
+    name: "gdocs_insert_link",
+    description: "Insert a hyperlink on a text range in a Google Document.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            startIndex: {
+                type: "number",
+                description: "Start position of text to link (1-based, inclusive)",
+            },
+            endIndex: {
+                type: "number",
+                description: "End position of text to link (1-based, exclusive)",
+            },
+            url: {
+                type: "string",
+                description: "URL to link to (must start with http:// or https://)",
+            },
+        },
+        required: ["documentId", "startIndex", "endIndex", "url"],
+    },
+};
+export async function insertLink(args) {
+    try {
+        // Validate inputs
+        if (!Validator.validateRange(args.startIndex, args.endIndex)) {
+            throw new Error("Invalid range: startIndex must be less than endIndex and both must be positive");
+        }
+        if (!Validator.validateUrl(args.url)) {
+            throw new Error("Invalid URL: must start with http:// or https://");
+        }
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        updateTextStyle: {
+                            textStyle: {
+                                link: {
+                                    url: args.url,
+                                },
+                            },
+                            fields: "link",
+                            range: {
+                                startIndex: args.startIndex,
+                                endIndex: args.endIndex,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            url: args.url,
+            range: {
+                startIndex: args.startIndex,
+                endIndex: args.endIndex,
+            },
+        }, "Hyperlink inserted successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/elements/gdocs_insert_page_break.js

@@ -0,0 +1,55 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+import { Validator } from "../../../lib/validation.js";
+export const schema = {
+    name: "gdocs_insert_page_break",
+    description: "Insert a page break at a specific position in a Google Document.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            index: {
+                type: "number",
+                description: "Position to insert page break (1-based)",
+            },
+        },
+        required: ["documentId", "index"],
+    },
+};
+export async function insertPageBreak(args) {
+    try {
+        // Validate inputs
+        if (!Validator.validateIndex(args.index)) {
+            throw new Error("Index must be a positive integer");
+        }
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        insertPageBreak: {
+                            location: {
+                                index: args.index,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            insertedAt: args.index,
+        }, "Page break inserted successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/elements/gdocs_insert_toc.js

@@ -0,0 +1,71 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+import { Validator } from "../../../lib/validation.js";
+export const schema = {
+    name: "gdocs_insert_toc",
+    description: "Insert a 'Table of Contents' heading at a specific position. NOTE: The Google Docs API doesn't support auto-generated TOC insertion. To insert an actual auto-updating TOC, use Insert > Table of contents in the Google Docs UI.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            index: {
+                type: "number",
+                description: "Position to insert TOC heading (1-based)",
+            },
+        },
+        required: ["documentId", "index"],
+    },
+};
+export async function insertToc(args) {
+    try {
+        // Validate inputs
+        if (!Validator.validateIndex(args.index)) {
+            throw new Error("Index must be a positive integer");
+        }
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        // NOTE: Google Docs API doesn't support programmatic TOC insertion
+        // This is a workaround that inserts a styled "Table of Contents" heading
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        insertText: {
+                            location: {
+                                index: args.index,
+                            },
+                            text: "Table of Contents\n",
+                        },
+                    },
+                    {
+                        updateParagraphStyle: {
+                            range: {
+                                startIndex: args.index,
+                                endIndex: args.index + 19, // "Table of Contents\n".length
+                            },
+                            paragraphStyle: {
+                                namedStyleType: "HEADING_1",
+                            },
+                            fields: "namedStyleType",
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            insertedAt: args.index,
+            note: "Inserted 'Table of Contents' heading. To insert an auto-updating TOC, use Insert > Table of contents in the Google Docs UI. The API doesn't support programmatic TOC generation.",
+        }, "Table of Contents heading inserted successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}