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

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

@@ -0,0 +1,137 @@
+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_format_text",
+    description: "Apply text formatting (bold, italic, font, color, etc.) to a 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 format (1-based, inclusive)",
+            },
+            endIndex: {
+                type: "number",
+                description: "End position of text to format (1-based, exclusive)",
+            },
+            format: {
+                type: "object",
+                description: "Formatting options to apply",
+                properties: {
+                    bold: { type: "boolean", description: "Make text bold" },
+                    italic: { type: "boolean", description: "Make text italic" },
+                    underline: { type: "boolean", description: "Underline text" },
+                    fontSize: { type: "number", description: "Font size in points" },
+                    fontFamily: { type: "string", description: "Font family (e.g., 'Arial', 'Times New Roman')" },
+                    foregroundColor: {
+                        type: "object",
+                        description: "Text color (RGB values 0-1)",
+                        properties: {
+                            red: { type: "number" },
+                            green: { type: "number" },
+                            blue: { type: "number" },
+                        },
+                    },
+                    backgroundColor: {
+                        type: "object",
+                        description: "Background color (RGB values 0-1)",
+                        properties: {
+                            red: { type: "number" },
+                            green: { type: "number" },
+                            blue: { type: "number" },
+                        },
+                    },
+                },
+            },
+        },
+        required: ["documentId", "startIndex", "endIndex", "format"],
+    },
+};
+export async function formatText(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.validateTextStyle(args.format)) {
+            throw new Error("Invalid format: at least one formatting property must be specified");
+        }
+        // Validate colors if provided
+        if (args.format.foregroundColor && !Validator.validateColor(args.format.foregroundColor)) {
+            throw new Error("Invalid foregroundColor: RGB values must be between 0 and 1");
+        }
+        if (args.format.backgroundColor && !Validator.validateColor(args.format.backgroundColor)) {
+            throw new Error("Invalid backgroundColor: RGB values must be between 0 and 1");
+        }
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        // Build text style object
+        const textStyle = {};
+        if (args.format.bold !== undefined)
+            textStyle.bold = args.format.bold;
+        if (args.format.italic !== undefined)
+            textStyle.italic = args.format.italic;
+        if (args.format.underline !== undefined)
+            textStyle.underline = args.format.underline;
+        if (args.format.fontSize) {
+            textStyle.fontSize = {
+                magnitude: args.format.fontSize,
+                unit: "PT",
+            };
+        }
+        if (args.format.fontFamily)
+            textStyle.weightedFontFamily = { fontFamily: args.format.fontFamily };
+        if (args.format.foregroundColor) {
+            textStyle.foregroundColor = {
+                color: {
+                    rgbColor: args.format.foregroundColor,
+                },
+            };
+        }
+        if (args.format.backgroundColor) {
+            textStyle.backgroundColor = {
+                color: {
+                    rgbColor: args.format.backgroundColor,
+                },
+            };
+        }
+        // Build fields mask
+        const fields = Object.keys(textStyle).join(",");
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        updateTextStyle: {
+                            textStyle,
+                            fields,
+                            range: {
+                                startIndex: args.startIndex,
+                                endIndex: args.endIndex,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            formattedRange: {
+                startIndex: args.startIndex,
+                endIndex: args.endIndex,
+            },
+            appliedFormats: Object.keys(args.format),
+        }, "Text formatted successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

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

@@ -0,0 +1,62 @@
+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_text",
+    description: "Insert text at a specific position in a Google Document. Position is 1-based (1 = start of document).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            text: {
+                type: "string",
+                description: "Text to insert",
+            },
+            index: {
+                type: "number",
+                description: "Position to insert text (1-based index, 1 = start of document)",
+            },
+        },
+        required: ["documentId", "text", "index"],
+    },
+};
+export async function insertText(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: [
+                    {
+                        insertText: {
+                            text: args.text,
+                            location: {
+                                index: args.index,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            insertedText: args.text,
+            insertedAt: args.index,
+            length: args.text.length,
+        }, "Text inserted successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

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

@@ -0,0 +1,64 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+export const schema = {
+    name: "gdocs_replace_text",
+    description: "Find and replace all occurrences of text in a Google Document.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            findText: {
+                type: "string",
+                description: "Text to find",
+            },
+            replaceText: {
+                type: "string",
+                description: "Text to replace with",
+            },
+            matchCase: {
+                type: "boolean",
+                description: "Whether to match case (default: false)",
+            },
+        },
+        required: ["documentId", "findText", "replaceText"],
+    },
+};
+export async function replaceText(args) {
+    try {
+        // 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: [
+                    {
+                        replaceAllText: {
+                            containsText: {
+                                text: args.findText,
+                                matchCase: args.matchCase || false,
+                            },
+                            replaceText: args.replaceText,
+                        },
+                    },
+                ],
+            },
+        });
+        // Get occurrences replaced from response
+        const occurrencesReplaced = response.data.replies?.[0]?.replaceAllText?.occurrencesChanged || 0;
+        return ResponseFormatter.success({
+            documentId,
+            findText: args.findText,
+            replaceText: args.replaceText,
+            occurrencesReplaced,
+        }, `Replaced ${occurrencesReplaced} occurrence(s)`);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

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

@@ -0,0 +1,76 @@
+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_set_alignment",
+    description: "Set paragraph alignment (left, center, right, justified) for a 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 paragraph to align (1-based, inclusive)",
+            },
+            endIndex: {
+                type: "number",
+                description: "End position of paragraph to align (1-based, exclusive)",
+            },
+            alignment: {
+                type: "string",
+                description: "Alignment type",
+                enum: ["START", "CENTER", "END", "JUSTIFIED"],
+            },
+        },
+        required: ["documentId", "startIndex", "endIndex", "alignment"],
+    },
+};
+export async function setAlignment(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.validateAlignment(args.alignment)) {
+            throw new Error("alignment must be one of: START, CENTER, END, JUSTIFIED");
+        }
+        // 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: [
+                    {
+                        updateParagraphStyle: {
+                            paragraphStyle: {
+                                alignment: args.alignment,
+                            },
+                            fields: "alignment",
+                            range: {
+                                startIndex: args.startIndex,
+                                endIndex: args.endIndex,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            alignment: args.alignment,
+            range: {
+                startIndex: args.startIndex,
+                endIndex: args.endIndex,
+            },
+        }, "Paragraph alignment set successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

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);
+    }
+}