@alanse/mcp-server-google-workspace 0.2.0

package/dist/tools/protection/gsheets_delete_named_range.js

@@ -0,0 +1,56 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_delete_named_range",
+    description: "Delete a named range from a spreadsheet",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            namedRangeId: {
+                type: "string",
+                description: "The ID of the named range to delete",
+            },
+        },
+        required: ["spreadsheetId", "namedRangeId"],
+    },
+};
+export async function deleteNamedRange(args) {
+    try {
+        const sheets = google.sheets("v4");
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        deleteNamedRange: {
+                            namedRangeId: args.namedRangeId,
+                        },
+                    },
+                ],
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully deleted named range ${args.namedRangeId}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error deleting named range: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/protection/gsheets_delete_protected_range.js

@@ -0,0 +1,56 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_delete_protected_range",
+    description: "Remove protection from a protected range",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            protectedRangeId: {
+                type: "number",
+                description: "The ID of the protected range to delete",
+            },
+        },
+        required: ["spreadsheetId", "protectedRangeId"],
+    },
+};
+export async function deleteProtectedRange(args) {
+    try {
+        const sheets = google.sheets("v4");
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        deleteProtectedRange: {
+                            protectedRangeId: args.protectedRangeId,
+                        },
+                    },
+                ],
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully deleted protected range ${args.protectedRangeId}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error deleting protected range: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/protection/gsheets_update_named_range.js

@@ -0,0 +1,112 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_update_named_range",
+    description: "Update a named range's properties",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            namedRangeId: {
+                type: "string",
+                description: "The ID of the named range to update",
+            },
+            name: {
+                type: "string",
+                description: "New name for the range (optional)",
+            },
+            sheetId: {
+                type: "number",
+                description: "The ID of the sheet (optional)",
+            },
+            startRow: {
+                type: "number",
+                description: "Starting row index (0-based, optional)",
+            },
+            endRow: {
+                type: "number",
+                description: "Ending row index (exclusive, 0-based, optional)",
+            },
+            startColumn: {
+                type: "number",
+                description: "Starting column index (0-based, optional)",
+            },
+            endColumn: {
+                type: "number",
+                description: "Ending column index (exclusive, 0-based, optional)",
+            },
+        },
+        required: ["spreadsheetId", "namedRangeId"],
+    },
+};
+export async function updateNamedRange(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const namedRange = {
+            namedRangeId: args.namedRangeId,
+        };
+        const fields = [];
+        if (args.name !== undefined) {
+            namedRange.name = args.name;
+            fields.push("name");
+        }
+        if (args.sheetId !== undefined ||
+            args.startRow !== undefined ||
+            args.endRow !== undefined ||
+            args.startColumn !== undefined ||
+            args.endColumn !== undefined) {
+            namedRange.range = {};
+            if (args.sheetId !== undefined) {
+                namedRange.range.sheetId = args.sheetId;
+            }
+            if (args.startRow !== undefined) {
+                namedRange.range.startRowIndex = args.startRow;
+            }
+            if (args.endRow !== undefined) {
+                namedRange.range.endRowIndex = args.endRow;
+            }
+            if (args.startColumn !== undefined) {
+                namedRange.range.startColumnIndex = args.startColumn;
+            }
+            if (args.endColumn !== undefined) {
+                namedRange.range.endColumnIndex = args.endColumn;
+            }
+            fields.push("range");
+        }
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        updateNamedRange: {
+                            namedRange,
+                            fields: fields.join(","),
+                        },
+                    },
+                ],
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully updated named range ${args.namedRangeId}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error updating named range: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/protection/gsheets_update_protected_range.js

@@ -0,0 +1,110 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_update_protected_range",
+    description: "Update protection settings for a protected range",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            protectedRangeId: {
+                type: "number",
+                description: "The ID of the protected range to update",
+            },
+            description: {
+                type: "string",
+                description: "New description for the protected range",
+            },
+            warningOnly: {
+                type: "boolean",
+                description: "If true, show a warning instead of preventing edits",
+            },
+            editors: {
+                type: "object",
+                properties: {
+                    users: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Email addresses of users who can edit",
+                    },
+                    groups: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Email addresses of groups who can edit",
+                    },
+                    domainUsersCanEdit: {
+                        type: "boolean",
+                        description: "Whether all users in the domain can edit",
+                    },
+                },
+                description: "Who can edit the protected range",
+            },
+        },
+        required: ["spreadsheetId", "protectedRangeId"],
+    },
+};
+export async function updateProtectedRange(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const protectedRange = {
+            protectedRangeId: args.protectedRangeId,
+        };
+        const fields = [];
+        if (args.description !== undefined) {
+            protectedRange.description = args.description;
+            fields.push("description");
+        }
+        if (args.warningOnly !== undefined) {
+            protectedRange.warningOnly = args.warningOnly;
+            fields.push("warningOnly");
+        }
+        if (args.editors) {
+            protectedRange.editors = {};
+            if (args.editors.users !== undefined) {
+                protectedRange.editors.users = args.editors.users;
+            }
+            if (args.editors.groups !== undefined) {
+                protectedRange.editors.groups = args.editors.groups;
+            }
+            if (args.editors.domainUsersCanEdit !== undefined) {
+                protectedRange.editors.domainUsersCanEdit = args.editors.domainUsersCanEdit;
+            }
+            fields.push("editors");
+        }
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        updateProtectedRange: {
+                            protectedRange,
+                            fields: fields.join(","),
+                        },
+                    },
+                ],
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully updated protected range ${args.protectedRangeId}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error updating protected range: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

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

@@ -0,0 +1,75 @@
+import { google } from 'googleapis';
+export const schema = {
+    name: "gsheets_add_dimension_group",
+    description: "Add a dimension group (row or column group) to a Google Sheet. Allows creating collapsible groups of rows or columns.",
+    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 to 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)"
+            }
+        },
+        required: ["spreadsheetId", "sheetId", "dimension", "startIndex", "endIndex"]
+    }
+};
+export async function addDimensionGroup(args) {
+    try {
+        const sheets = google.sheets("v4");
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        addDimensionGroup: {
+                            range: {
+                                sheetId: args.sheetId,
+                                dimension: args.dimension,
+                                startIndex: args.startIndex,
+                                endIndex: args.endIndex,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully added ${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 adding dimension group: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

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

@@ -0,0 +1,86 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_add_filter_view",
+    description: "Create a filter view in a spreadsheet",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            sheetId: {
+                type: "number",
+                description: "The ID of the sheet",
+            },
+            title: {
+                type: "string",
+                description: "Title of the filter view",
+            },
+            startRow: {
+                type: "number",
+                description: "Starting row index (0-based)",
+            },
+            endRow: {
+                type: "number",
+                description: "Ending row index (exclusive, 0-based)",
+            },
+            startColumn: {
+                type: "number",
+                description: "Starting column index (0-based)",
+            },
+            endColumn: {
+                type: "number",
+                description: "Ending column index (exclusive, 0-based)",
+            },
+        },
+        required: ["spreadsheetId", "sheetId", "title", "startRow", "endRow", "startColumn", "endColumn"],
+    },
+};
+export async function addFilterView(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const response = await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        addFilterView: {
+                            filter: {
+                                title: args.title,
+                                range: {
+                                    sheetId: args.sheetId,
+                                    startRowIndex: args.startRow,
+                                    endRowIndex: args.endRow,
+                                    startColumnIndex: args.startColumn,
+                                    endColumnIndex: args.endColumn,
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        const filterViewId = response.data.replies?.[0]?.addFilterView?.filter?.filterViewId;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully created filter view "${args.title}". Filter View ID: ${filterViewId}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error creating filter view: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

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

@@ -0,0 +1,188 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_add_pivot_table",
+    description: "Create a pivot table in a spreadsheet",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            sourceSheetId: {
+                type: "number",
+                description: "The sheet ID containing source data",
+            },
+            sourceStartRow: {
+                type: "number",
+                description: "Starting row of source data (0-based)",
+            },
+            sourceEndRow: {
+                type: "number",
+                description: "Ending row of source data (exclusive, 0-based)",
+            },
+            sourceStartColumn: {
+                type: "number",
+                description: "Starting column of source data (0-based)",
+            },
+            sourceEndColumn: {
+                type: "number",
+                description: "Ending column of source data (exclusive, 0-based)",
+            },
+            targetSheetId: {
+                type: "number",
+                description: "The sheet ID where pivot table will be placed",
+            },
+            targetRow: {
+                type: "number",
+                description: "Row position for pivot table (0-based)",
+            },
+            targetColumn: {
+                type: "number",
+                description: "Column position for pivot table (0-based)",
+            },
+            rows: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        sourceColumnOffset: {
+                            type: "number",
+                            description: "Column offset in source data (0-based)",
+                        },
+                        sortOrder: {
+                            type: "string",
+                            enum: ["ASCENDING", "DESCENDING"],
+                            description: "Sort order for this row group",
+                        },
+                        showTotals: {
+                            type: "boolean",
+                            description: "Show totals for this row group",
+                        },
+                    },
+                    required: ["sourceColumnOffset"],
+                },
+                description: "Row groups for pivot table",
+            },
+            columns: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        sourceColumnOffset: {
+                            type: "number",
+                            description: "Column offset in source data (0-based)",
+                        },
+                        sortOrder: {
+                            type: "string",
+                            enum: ["ASCENDING", "DESCENDING"],
+                            description: "Sort order for this column group",
+                        },
+                        showTotals: {
+                            type: "boolean",
+                            description: "Show totals for this column group",
+                        },
+                    },
+                    required: ["sourceColumnOffset"],
+                },
+                description: "Column groups for pivot table (optional)",
+            },
+            values: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        sourceColumnOffset: {
+                            type: "number",
+                            description: "Column offset in source data (0-based)",
+                        },
+                        summarizeFunction: {
+                            type: "string",
+                            enum: ["SUM", "COUNT", "AVERAGE", "MAX", "MIN", "MEDIAN", "PRODUCT", "STDEV", "STDEVP", "VAR", "VARP"],
+                            description: "Function to aggregate values",
+                        },
+                    },
+                    required: ["sourceColumnOffset", "summarizeFunction"],
+                },
+                description: "Values to aggregate in pivot table",
+            },
+        },
+        required: ["spreadsheetId", "sourceSheetId", "sourceStartRow", "sourceEndRow", "sourceStartColumn", "sourceEndColumn", "targetSheetId", "targetRow", "targetColumn", "rows", "values"],
+    },
+};
+export async function addPivotTable(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const pivotTable = {
+            source: {
+                sheetId: args.sourceSheetId,
+                startRowIndex: args.sourceStartRow,
+                endRowIndex: args.sourceEndRow,
+                startColumnIndex: args.sourceStartColumn,
+                endColumnIndex: args.sourceEndColumn,
+            },
+            rows: args.rows.map((row) => ({
+                sourceColumnOffset: row.sourceColumnOffset,
+                showTotals: row.showTotals !== false,
+                sortOrder: row.sortOrder || "ASCENDING",
+            })),
+            values: args.values.map((value) => ({
+                sourceColumnOffset: value.sourceColumnOffset,
+                summarizeFunction: value.summarizeFunction,
+            })),
+        };
+        if (args.columns && args.columns.length > 0) {
+            pivotTable.columns = args.columns.map((column) => ({
+                sourceColumnOffset: column.sourceColumnOffset,
+                showTotals: column.showTotals !== false,
+                sortOrder: column.sortOrder || "ASCENDING",
+            }));
+        }
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        updateCells: {
+                            rows: [
+                                {
+                                    values: [
+                                        {
+                                            pivotTable,
+                                        },
+                                    ],
+                                },
+                            ],
+                            fields: "pivotTable",
+                            start: {
+                                sheetId: args.targetSheetId,
+                                rowIndex: args.targetRow,
+                                columnIndex: args.targetColumn,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully created pivot table at sheet ${args.targetSheetId}, position R${args.targetRow}C${args.targetColumn}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error creating pivot table: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}