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

package/dist/tools/calendar/settings/calendar_settings_list.js

@@ -0,0 +1,81 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+export const schema = {
+    name: "calendar_settings_list",
+    description: "List all user settings for the authenticated user's Google Calendar. Returns configuration settings such as timezone, date format, country, language, and other Calendar preferences. Useful for understanding user's Calendar configuration.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            maxResults: {
+                type: "number",
+                description: "Maximum number of settings to return per page (default: 100, max: 250)",
+            },
+            pageToken: {
+                type: "string",
+                description: "Token for accessing subsequent result pages",
+            },
+        },
+        required: [],
+    },
+};
+export async function listSettings(args = {}) {
+    try {
+        const calendar = google.calendar("v3");
+        const { maxResults, pageToken, } = args;
+        const response = await calendar.settings.list({
+            maxResults,
+            pageToken,
+        });
+        const settings = response.data.items || [];
+        const totalSettings = settings.length;
+        if (totalSettings === 0) {
+            return ResponseFormatter.success({ settings: [], count: 0 }, "No settings found.");
+        }
+        let message = `⚙️ Calendar Settings (${totalSettings} setting${totalSettings > 1 ? "s" : ""})\n\n`;
+        // Group settings by category for better readability
+        const categorizedSettings = {
+            "General": [],
+            "Time & Date": [],
+            "Locale": [],
+            "Other": [],
+        };
+        settings.forEach((setting) => {
+            const id = setting.id || "";
+            if (id.includes("timezone") || id.includes("time") || id.includes("date") || id.includes("hour")) {
+                categorizedSettings["Time & Date"].push(setting);
+            }
+            else if (id.includes("locale") || id.includes("language") || id.includes("country")) {
+                categorizedSettings["Locale"].push(setting);
+            }
+            else if (id.includes("format") || id.includes("weekStart") || id.includes("show")) {
+                categorizedSettings["General"].push(setting);
+            }
+            else {
+                categorizedSettings["Other"].push(setting);
+            }
+        });
+        // Display settings by category
+        Object.entries(categorizedSettings).forEach(([category, items]) => {
+            if (items.length > 0) {
+                message += `\n${category}:\n`;
+                items.forEach((setting) => {
+                    message += `  ${setting.id}: ${setting.value}\n`;
+                });
+            }
+        });
+        if (response.data.nextPageToken) {
+            message += `\n\n📄 Next Page Token: ${response.data.nextPageToken}`;
+        }
+        return ResponseFormatter.success({
+            settings: settings.map((s) => ({
+                id: s.id,
+                value: s.value,
+            })),
+            count: totalSettings,
+            nextPageToken: response.data.nextPageToken || null,
+        }, message);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/basic/gdocs_create.js

@@ -0,0 +1,37 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+export const schema = {
+    name: "gdocs_create",
+    description: "Create a new Google Document",
+    inputSchema: {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "The title of the new document",
+            },
+        },
+        required: ["title"],
+    },
+};
+export async function createDocument(args) {
+    try {
+        const docs = google.docs("v1");
+        const response = await docs.documents.create({
+            requestBody: {
+                title: args.title,
+            },
+        });
+        const documentId = response.data.documentId;
+        const documentUrl = `https://docs.google.com/document/d/${documentId}/edit`;
+        return ResponseFormatter.success({
+            documentId,
+            documentUrl,
+            title: response.data.title,
+            revisionId: response.data.revisionId,
+        }, "Document created successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/basic/gdocs_get_metadata.js

@@ -0,0 +1,45 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+export const schema = {
+    name: "gdocs_get_metadata",
+    description: "Get metadata for a Google Document including title, revision ID, and document style. Accepts either a document ID or a full Google Docs URL.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL (e.g., https://docs.google.com/document/d/DOCUMENT_ID/edit)",
+            },
+        },
+        required: ["documentId"],
+    },
+};
+export async function getMetadata(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.get({
+            documentId,
+        });
+        const doc = response.data;
+        const metadata = {
+            documentId: doc.documentId,
+            title: doc.title,
+            revisionId: doc.revisionId,
+            suggestionsViewMode: doc.suggestionsViewMode,
+            documentStyle: doc.documentStyle,
+            namedStyles: doc.namedStyles,
+            headers: Object.keys(doc.headers || {}).length,
+            footers: Object.keys(doc.footers || {}).length,
+            inlineObjects: Object.keys(doc.inlineObjects || {}).length,
+            lists: Object.keys(doc.lists || {}).length,
+        };
+        return ResponseFormatter.success(metadata, "Document metadata retrieved successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/basic/gdocs_list_documents.js

@@ -0,0 +1,59 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+export const schema = {
+    name: "gdocs_list_documents",
+    description: "List Google Documents from Google Drive. Use query parameter to filter by name, owner, etc.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "Search query to filter documents (e.g., 'name contains \"report\"'). Default: list all documents",
+            },
+            pageToken: {
+                type: "string",
+                description: "Token for pagination to get the next page of results",
+            },
+            pageSize: {
+                type: "number",
+                description: "Maximum number of documents to return (default: 10, max: 100)",
+            },
+        },
+        required: [],
+    },
+};
+export async function listDocuments(args) {
+    try {
+        const drive = google.drive("v3");
+        // Build query to find Google Docs files
+        let query = "mimeType='application/vnd.google-apps.document'";
+        if (args.query) {
+            query += ` and ${args.query}`;
+        }
+        const response = await drive.files.list({
+            q: query,
+            pageSize: args.pageSize || 10,
+            pageToken: args.pageToken,
+            fields: "nextPageToken, files(id, name, createdTime, modifiedTime, owners, webViewLink)",
+            orderBy: "modifiedTime desc",
+        });
+        const files = response.data.files || [];
+        const documents = files.map((file) => ({
+            documentId: file.id,
+            name: file.name,
+            createdTime: file.createdTime,
+            modifiedTime: file.modifiedTime,
+            owners: file.owners?.map((owner) => owner.emailAddress),
+            webViewLink: file.webViewLink,
+        }));
+        const result = {
+            documents,
+            count: documents.length,
+            nextPageToken: response.data.nextPageToken,
+        };
+        return ResponseFormatter.success(result, `Found ${documents.length} document(s)`);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/basic/gdocs_read.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_read",
+    description: "Read content from a Google Document. Accepts either a document ID or a full Google Docs URL.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL (e.g., https://docs.google.com/document/d/DOCUMENT_ID/edit)",
+            },
+            includeFormatting: {
+                type: "boolean",
+                description: "Whether to include text formatting information (default: false)",
+            },
+        },
+        required: ["documentId"],
+    },
+};
+export async function readDocument(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.get({
+            documentId,
+        });
+        const doc = response.data;
+        // Extract plain text content
+        let textContent = "";
+        if (doc.body?.content) {
+            for (const element of doc.body.content) {
+                if (element.paragraph?.elements) {
+                    for (const textElement of element.paragraph.elements) {
+                        if (textElement.textRun?.content) {
+                            textContent += textElement.textRun.content;
+                        }
+                    }
+                }
+            }
+        }
+        const result = {
+            documentId: doc.documentId,
+            title: doc.title,
+            revisionId: doc.revisionId,
+            textContent,
+        };
+        // Include formatting if requested
+        if (args.includeFormatting) {
+            result.body = doc.body;
+            result.documentStyle = doc.documentStyle;
+            result.namedStyles = doc.namedStyles;
+        }
+        return ResponseFormatter.success(result, "Document read successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

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

@@ -0,0 +1,57 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+export const schema = {
+    name: "gdocs_append_text",
+    description: "Append text to the end of a Google Document.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            text: {
+                type: "string",
+                description: "Text to append to the end of the document",
+            },
+        },
+        required: ["documentId", "text"],
+    },
+};
+export async function appendText(args) {
+    try {
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        // First get the document to find the end index
+        const doc = await docs.documents.get({ documentId });
+        const endIndex = doc.data.body?.content?.[doc.data.body.content.length - 1]?.endIndex || 1;
+        // Insert text at the end (endIndex - 1 because endIndex is exclusive)
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        insertText: {
+                            text: args.text,
+                            location: {
+                                index: endIndex - 1,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            appendedText: args.text,
+            appendedAt: endIndex - 1,
+            length: args.text.length,
+        }, "Text appended successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

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

@@ -0,0 +1,86 @@
+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_apply_style",
+    description: "Apply a named style (Normal, Heading 1-6, Title, Subtitle) to a paragraph 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 style (1-based, inclusive)",
+            },
+            endIndex: {
+                type: "number",
+                description: "End position of paragraph to style (1-based, exclusive)",
+            },
+            namedStyleType: {
+                type: "string",
+                description: "Named style to apply",
+                enum: [
+                    "NORMAL_TEXT",
+                    "HEADING_1",
+                    "HEADING_2",
+                    "HEADING_3",
+                    "HEADING_4",
+                    "HEADING_5",
+                    "HEADING_6",
+                    "TITLE",
+                    "SUBTITLE",
+                ],
+            },
+        },
+        required: ["documentId", "startIndex", "endIndex", "namedStyleType"],
+    },
+};
+export async function applyStyle(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.validateNamedStyleType(args.namedStyleType)) {
+            throw new Error("Invalid namedStyleType. Must be one of: NORMAL_TEXT, HEADING_1-6, TITLE, SUBTITLE");
+        }
+        // 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: {
+                                namedStyleType: args.namedStyleType,
+                            },
+                            fields: "namedStyleType",
+                            range: {
+                                startIndex: args.startIndex,
+                                endIndex: args.endIndex,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            namedStyleType: args.namedStyleType,
+            range: {
+                startIndex: args.startIndex,
+                endIndex: args.endIndex,
+            },
+        }, `Style '${args.namedStyleType}' applied successfully`);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

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

@@ -0,0 +1,89 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+export const schema = {
+    name: "gdocs_create_heading",
+    description: "Create a heading (H1-H6) in a Google Document. If index is not provided, appends to end.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            text: {
+                type: "string",
+                description: "Heading text",
+            },
+            level: {
+                type: "number",
+                description: "Heading level (1-6, where 1 is H1, 2 is H2, etc.)",
+                enum: [1, 2, 3, 4, 5, 6],
+            },
+            index: {
+                type: "number",
+                description: "Position to insert heading (1-based). If not provided, appends to end.",
+            },
+        },
+        required: ["documentId", "text", "level"],
+    },
+};
+export async function createHeading(args) {
+    try {
+        // Validate level
+        if (![1, 2, 3, 4, 5, 6].includes(args.level)) {
+            throw new Error("Level must be between 1 and 6");
+        }
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        // Determine insertion index
+        let insertIndex = args.index;
+        if (!insertIndex) {
+            const doc = await docs.documents.get({ documentId });
+            const endIndex = doc.data.body?.content?.[doc.data.body.content.length - 1]?.endIndex || 1;
+            insertIndex = endIndex - 1;
+        }
+        // Map level to named style
+        const namedStyleType = `HEADING_${args.level}`;
+        const headingText = args.text + "\n";
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        insertText: {
+                            text: headingText,
+                            location: {
+                                index: insertIndex,
+                            },
+                        },
+                    },
+                    {
+                        updateParagraphStyle: {
+                            paragraphStyle: {
+                                namedStyleType,
+                            },
+                            fields: "namedStyleType",
+                            range: {
+                                startIndex: insertIndex,
+                                endIndex: insertIndex + headingText.length,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            headingText: args.text,
+            level: args.level,
+            insertedAt: insertIndex,
+            namedStyleType,
+        }, `Heading ${args.level} created successfully`);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

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

@@ -0,0 +1,86 @@
+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_list",
+    description: "Convert a range of paragraphs into a bulleted or numbered list 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 convert to list (1-based, inclusive)",
+            },
+            endIndex: {
+                type: "number",
+                description: "End position of text to convert to list (1-based, exclusive)",
+            },
+            listType: {
+                type: "string",
+                description: "Type of list to create",
+                enum: ["ORDERED", "UNORDERED"],
+            },
+            nestingLevel: {
+                type: "number",
+                description: "Nesting level of the list (0-8, default: 0)",
+            },
+        },
+        required: ["documentId", "startIndex", "endIndex", "listType"],
+    },
+};
+export async function createList(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 (!["ORDERED", "UNORDERED"].includes(args.listType)) {
+            throw new Error("listType must be either 'ORDERED' or 'UNORDERED'");
+        }
+        const nestingLevel = args.nestingLevel || 0;
+        if (nestingLevel < 0 || nestingLevel > 8) {
+            throw new Error("nestingLevel must be between 0 and 8");
+        }
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        // Map list type to glyph type
+        const glyphType = args.listType === "ORDERED" ? undefined : "GLYPH_TYPE_UNSPECIFIED";
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        createParagraphBullets: {
+                            range: {
+                                startIndex: args.startIndex,
+                                endIndex: args.endIndex,
+                            },
+                            bulletPreset: args.listType === "ORDERED"
+                                ? "NUMBERED_DECIMAL_ALPHA_ROMAN"
+                                : "BULLET_DISC_CIRCLE_SQUARE",
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            listType: args.listType,
+            range: {
+                startIndex: args.startIndex,
+                endIndex: args.endIndex,
+            },
+            nestingLevel,
+        }, `List created successfully (${args.listType.toLowerCase()})`);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/content/gdocs_delete_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";
+import { Validator } from "../../../lib/validation.js";
+export const schema = {
+    name: "gdocs_delete_text",
+    description: "Delete text in a specific range from 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 delete (1-based, inclusive)",
+            },
+            endIndex: {
+                type: "number",
+                description: "End position of text to delete (1-based, exclusive)",
+            },
+        },
+        required: ["documentId", "startIndex", "endIndex"],
+    },
+};
+export async function deleteText(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");
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        deleteContentRange: {
+                            range: {
+                                startIndex: args.startIndex,
+                                endIndex: args.endIndex,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            deletedRange: {
+                startIndex: args.startIndex,
+                endIndex: args.endIndex,
+            },
+            deletedLength: args.endIndex - args.startIndex,
+        }, "Text deleted successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}