@alanse/mcp-server-google-workspace 0.2.0

package/dist/tools/sheets/advanced/gsheets_create_developer_metadata.js

@@ -0,0 +1,121 @@
+import { google } from 'googleapis';
+export const schema = {
+    name: "gsheets_create_developer_metadata",
+    description: "Create developer metadata for a spreadsheet, sheet, row, or column. Allows storing custom key-value metadata.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet"
+            },
+            location: {
+                type: "object",
+                description: "The location where the metadata should be attached",
+                properties: {
+                    type: {
+                        type: "string",
+                        enum: ["SPREADSHEET", "SHEET", "ROW", "COLUMN"],
+                        description: "The type of location"
+                    },
+                    sheetId: {
+                        type: "number",
+                        description: "The sheet ID (required for SHEET, ROW, COLUMN)"
+                    },
+                    dimensionRange: {
+                        type: "object",
+                        description: "The dimension range (required for ROW, COLUMN)",
+                        properties: {
+                            dimension: {
+                                type: "string",
+                                enum: ["ROWS", "COLUMNS"]
+                            },
+                            startIndex: {
+                                type: "number"
+                            },
+                            endIndex: {
+                                type: "number"
+                            }
+                        }
+                    }
+                },
+                required: ["type"]
+            },
+            metadataKey: {
+                type: "string",
+                description: "The metadata key"
+            },
+            metadataValue: {
+                type: "string",
+                description: "The metadata value"
+            },
+            visibility: {
+                type: "string",
+                enum: ["DOCUMENT", "PROJECT"],
+                description: "The visibility of the metadata (DOCUMENT or PROJECT)"
+            }
+        },
+        required: ["spreadsheetId", "location", "metadataKey", "metadataValue", "visibility"]
+    }
+};
+export async function createDeveloperMetadata(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const metadataLocation = {};
+        if (args.location.type === "SPREADSHEET") {
+            metadataLocation.spreadsheet = true;
+        }
+        else if (args.location.type === "SHEET" && args.location.sheetId !== undefined) {
+            metadataLocation.sheetId = args.location.sheetId;
+        }
+        else if ((args.location.type === "ROW" || args.location.type === "COLUMN") &&
+            args.location.sheetId !== undefined &&
+            args.location.dimensionRange) {
+            metadataLocation.dimensionRange = {
+                sheetId: args.location.sheetId,
+                dimension: args.location.dimensionRange.dimension,
+                startIndex: args.location.dimensionRange.startIndex,
+                endIndex: args.location.dimensionRange.endIndex,
+            };
+        }
+        const response = await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        createDeveloperMetadata: {
+                            developerMetadata: {
+                                location: metadataLocation,
+                                metadataKey: args.metadataKey,
+                                metadataValue: args.metadataValue,
+                                visibility: args.visibility,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        const metadataId = response.data.replies?.[0]?.createDeveloperMetadata?.developerMetadata?.metadataId;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully created developer metadata with key "${args.metadataKey}" and value "${args.metadataValue}". Metadata ID: ${metadataId}.`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error creating developer metadata: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/sheets/advanced/gsheets_delete_developer_metadata.js

@@ -0,0 +1,61 @@
+import { google } from 'googleapis';
+export const schema = {
+    name: "gsheets_delete_developer_metadata",
+    description: "Delete developer metadata by metadata ID.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet"
+            },
+            metadataId: {
+                type: "number",
+                description: "The ID of the metadata to delete"
+            }
+        },
+        required: ["spreadsheetId", "metadataId"]
+    }
+};
+export async function deleteDeveloperMetadata(args) {
+    try {
+        const sheets = google.sheets("v4");
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        deleteDeveloperMetadata: {
+                            dataFilter: {
+                                developerMetadataLookup: {
+                                    metadataId: args.metadataId,
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully deleted developer metadata with ID ${args.metadataId}.`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error deleting developer metadata: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/sheets/advanced/gsheets_delete_dimension_group.js

@@ -0,0 +1,75 @@
+import { google } from 'googleapis';
+export const schema = {
+    name: "gsheets_delete_dimension_group",
+    description: "Delete a dimension group (row or column group) from a Google Sheet.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet"
+            },
+            sheetId: {
+                type: "number",
+                description: "The ID of the sheet"
+            },
+            dimension: {
+                type: "string",
+                enum: ["ROWS", "COLUMNS"],
+                description: "The dimension of the group to delete (ROWS or COLUMNS)"
+            },
+            startIndex: {
+                type: "number",
+                description: "The start index of the dimension group to delete (inclusive)"
+            },
+            endIndex: {
+                type: "number",
+                description: "The end index of the dimension group to delete (exclusive)"
+            }
+        },
+        required: ["spreadsheetId", "sheetId", "dimension", "startIndex", "endIndex"]
+    }
+};
+export async function deleteDimensionGroup(args) {
+    try {
+        const sheets = google.sheets("v4");
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        deleteDimensionGroup: {
+                            range: {
+                                sheetId: args.sheetId,
+                                dimension: args.dimension,
+                                startIndex: args.startIndex,
+                                endIndex: args.endIndex,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully deleted ${args.dimension.toLowerCase()} group from index ${args.startIndex} to ${args.endIndex} on sheet ${args.sheetId}.`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error deleting dimension group: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/sheets/advanced/gsheets_update_developer_metadata.js

@@ -0,0 +1,94 @@
+import { google } from 'googleapis';
+export const schema = {
+    name: "gsheets_update_developer_metadata",
+    description: "Update existing developer metadata by metadata ID.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet"
+            },
+            metadataId: {
+                type: "number",
+                description: "The ID of the metadata to update"
+            },
+            metadataKey: {
+                type: "string",
+                description: "The new metadata key (optional)"
+            },
+            metadataValue: {
+                type: "string",
+                description: "The new metadata value (optional)"
+            },
+            visibility: {
+                type: "string",
+                enum: ["DOCUMENT", "PROJECT"],
+                description: "The new visibility (optional)"
+            }
+        },
+        required: ["spreadsheetId", "metadataId"]
+    }
+};
+export async function updateDeveloperMetadata(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const fields = [];
+        const developerMetadata = {
+            metadataId: args.metadataId,
+        };
+        if (args.metadataKey !== undefined) {
+            developerMetadata.metadataKey = args.metadataKey;
+            fields.push("metadataKey");
+        }
+        if (args.metadataValue !== undefined) {
+            developerMetadata.metadataValue = args.metadataValue;
+            fields.push("metadataValue");
+        }
+        if (args.visibility !== undefined) {
+            developerMetadata.visibility = args.visibility;
+            fields.push("visibility");
+        }
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        updateDeveloperMetadata: {
+                            dataFilters: [
+                                {
+                                    developerMetadataLookup: {
+                                        metadataId: args.metadataId,
+                                    },
+                                },
+                            ],
+                            developerMetadata,
+                            fields: fields.join(","),
+                        },
+                    },
+                ],
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully updated developer metadata with ID ${args.metadataId}.`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error updating developer metadata: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/sheets/advanced/gsheets_update_dimension_group.js

@@ -0,0 +1,83 @@
+import { google } from 'googleapis';
+export const schema = {
+    name: "gsheets_update_dimension_group",
+    description: "Update properties of a dimension group (row or column group) such as collapse state or depth.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet"
+            },
+            sheetId: {
+                type: "number",
+                description: "The ID of the sheet"
+            },
+            dimension: {
+                type: "string",
+                enum: ["ROWS", "COLUMNS"],
+                description: "The dimension of the group (ROWS or COLUMNS)"
+            },
+            startIndex: {
+                type: "number",
+                description: "The start index of the dimension group (inclusive)"
+            },
+            endIndex: {
+                type: "number",
+                description: "The end index of the dimension group (exclusive)"
+            },
+            collapsed: {
+                type: "boolean",
+                description: "Whether the group should be collapsed"
+            }
+        },
+        required: ["spreadsheetId", "sheetId", "dimension", "startIndex", "endIndex", "collapsed"]
+    }
+};
+export async function updateDimensionGroup(args) {
+    try {
+        const sheets = google.sheets("v4");
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        updateDimensionGroup: {
+                            dimensionGroup: {
+                                range: {
+                                    sheetId: args.sheetId,
+                                    dimension: args.dimension,
+                                    startIndex: args.startIndex,
+                                    endIndex: args.endIndex,
+                                },
+                                collapsed: args.collapsed,
+                            },
+                            fields: "collapsed",
+                        },
+                    },
+                ],
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully updated ${args.dimension.toLowerCase()} group from index ${args.startIndex} to ${args.endIndex} on sheet ${args.sheetId}. Collapsed: ${args.collapsed}.`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error updating dimension group: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/sheets/basic/gsheets_add_sheet.js

@@ -0,0 +1,65 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_add_sheet",
+    description: "Add a new sheet (tab) to a Google Spreadsheet",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            title: {
+                type: "string",
+                description: "The name of the new sheet",
+            },
+            index: {
+                type: "number",
+                description: "Optional position index (0-based) where the sheet should be inserted",
+            },
+        },
+        required: ["spreadsheetId", "title"],
+    },
+};
+export async function addSheet(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const request = {
+            addSheet: {
+                properties: {
+                    title: args.title,
+                },
+            },
+        };
+        if (args.index !== undefined) {
+            request.addSheet.properties.index = args.index;
+        }
+        const response = await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [request],
+            },
+        });
+        const addedSheet = response.data.replies?.[0]?.addSheet?.properties;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully added sheet "${addedSheet?.title}" (ID: ${addedSheet?.sheetId}, Index: ${addedSheet?.index})`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error adding sheet: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/sheets/basic/gsheets_copy_sheet.js

@@ -0,0 +1,56 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_copy_sheet",
+    description: "Copy a sheet to another spreadsheet or within the same spreadsheet",
+    inputSchema: {
+        type: "object",
+        properties: {
+            sourceSpreadsheetId: {
+                type: "string",
+                description: "The ID of the source spreadsheet",
+            },
+            sourceSheetId: {
+                type: "number",
+                description: "The ID of the sheet to copy",
+            },
+            destinationSpreadsheetId: {
+                type: "string",
+                description: "The ID of the destination spreadsheet",
+            },
+        },
+        required: ["sourceSpreadsheetId", "sourceSheetId", "destinationSpreadsheetId"],
+    },
+};
+export async function copySheet(args) {
+    const sheets = google.sheets("v4");
+    try {
+        const response = await sheets.spreadsheets.sheets.copyTo({
+            spreadsheetId: args.sourceSpreadsheetId,
+            sheetId: args.sourceSheetId,
+            requestBody: {
+                destinationSpreadsheetId: args.destinationSpreadsheetId,
+            },
+        });
+        const copiedSheet = response.data;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully copied sheet to destination. New sheet ID: ${copiedSheet.sheetId}, Title: "${copiedSheet.title}"`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error copying sheet: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/sheets/basic/gsheets_copy_to.js

@@ -0,0 +1,113 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_copy_to",
+    description: "Copy data from one range to another range using cut/paste",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            sourceSheetId: {
+                type: "number",
+                description: "The ID of the source sheet",
+            },
+            sourceStartRow: {
+                type: "number",
+                description: "Source starting row index (0-based)",
+            },
+            sourceStartColumn: {
+                type: "number",
+                description: "Source starting column index (0-based)",
+            },
+            sourceEndRow: {
+                type: "number",
+                description: "Source ending row index (exclusive, 0-based)",
+            },
+            sourceEndColumn: {
+                type: "number",
+                description: "Source ending column index (exclusive, 0-based)",
+            },
+            destinationSheetId: {
+                type: "number",
+                description: "The ID of the destination sheet",
+            },
+            destinationStartRow: {
+                type: "number",
+                description: "Destination starting row index (0-based)",
+            },
+            destinationStartColumn: {
+                type: "number",
+                description: "Destination starting column index (0-based)",
+            },
+            pasteType: {
+                type: "string",
+                enum: ["NORMAL", "VALUES", "FORMAT", "FORMULA"],
+                description: "What to paste (default: NORMAL - all data)",
+            },
+        },
+        required: [
+            "spreadsheetId",
+            "sourceSheetId",
+            "sourceStartRow",
+            "sourceStartColumn",
+            "sourceEndRow",
+            "sourceEndColumn",
+            "destinationSheetId",
+            "destinationStartRow",
+            "destinationStartColumn",
+        ],
+    },
+};
+export async function copyTo(args) {
+    const sheets = google.sheets("v4");
+    try {
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        copyPaste: {
+                            source: {
+                                sheetId: args.sourceSheetId,
+                                startRowIndex: args.sourceStartRow,
+                                endRowIndex: args.sourceEndRow,
+                                startColumnIndex: args.sourceStartColumn,
+                                endColumnIndex: args.sourceEndColumn,
+                            },
+                            destination: {
+                                sheetId: args.destinationSheetId,
+                                startRowIndex: args.destinationStartRow,
+                                startColumnIndex: args.destinationStartColumn,
+                            },
+                            pasteType: args.pasteType || "NORMAL",
+                        },
+                    },
+                ],
+            },
+        });
+        const sourceRange = `R${args.sourceStartRow}C${args.sourceStartColumn}:R${args.sourceEndRow - 1}C${args.sourceEndColumn - 1}`;
+        const destRange = `R${args.destinationStartRow}C${args.destinationStartColumn}`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully copied data from sheet ${args.sourceSheetId} (${sourceRange}) to sheet ${args.destinationSheetId} (${destRange})`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error copying data: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}