@alanse/mcp-server-google-workspace 0.2.0

package/dist/tools/index.js

@@ -0,0 +1,294 @@
+// GDrive operations
+import { schema as gdriveSearchSchema, search } from './gdrive/gdrive_search.js';
+import { schema as gdriveReadFileSchema, readFile } from './gdrive/gdrive_read_file.js';
+// Basic operations
+import { schema as gsheetsReadSchema, readSheet } from './sheets/basic/gsheets_read.js';
+import { schema as gsheetsListSheetsSchema, listSheets } from './sheets/basic/gsheets_list_sheets.js';
+import { schema as gsheetsAddSheetSchema, addSheet } from './sheets/basic/gsheets_add_sheet.js';
+import { schema as gsheetsDeleteSheetSchema, deleteSheet } from './sheets/basic/gsheets_delete_sheet.js';
+import { schema as gsheetsInsertRowsSchema, insertRows } from './sheets/basic/gsheets_insert_rows.js';
+import { schema as gsheetsInsertColumnsSchema, insertColumns } from './sheets/basic/gsheets_insert_columns.js';
+import { schema as gsheetsDeleteRowsSchema, deleteRows } from './sheets/basic/gsheets_delete_rows.js';
+import { schema as gsheetsDeleteColumnsSchema, deleteColumns } from './sheets/basic/gsheets_delete_columns.js';
+import { schema as gsheetsCopySheetSchema, copySheet } from './sheets/basic/gsheets_copy_sheet.js';
+import { schema as gsheetsCopyToSchema, copyTo } from './sheets/basic/gsheets_copy_to.js';
+import { schema as gsheetsDuplicateSheetSchema, duplicateSheet } from './sheets/basic/gsheets_duplicate_sheet.js';
+import { schema as gsheetsRenameSheetSchema, renameSheet } from './sheets/basic/gsheets_rename_sheet.js';
+import { schema as gsheetsCreateSpreadsheetSchema, createSpreadsheet } from './sheets/basic/gsheets_create_spreadsheet.js';
+// Data operations
+import { schema as gsheetsUpdateCellSchema, updateCell } from './sheets/data/gsheets_update_cell.js';
+import { schema as gsheetsAppendDataSchema, appendData } from './sheets/data/gsheets_append_data.js';
+import { schema as gsheetsBatchUpdateSchema, batchUpdate } from './sheets/data/gsheets_batch_update.js';
+import { schema as gsheetsClearDataSchema, clearData } from './sheets/data/gsheets_clear_data.js';
+import { schema as gsheetsBatchClearSchema, batchClear } from './sheets/data/gsheets_batch_clear.js';
+import { schema as gsheetsSortRangeSchema, sortRange } from './sheets/data/gsheets_sort_range.js';
+import { schema as gsheetsFindReplaceSchema, findReplace } from './sheets/data/gsheets_find_replace.js';
+import { schema as gsheetsSetDataValidationSchema, setDataValidation } from './sheets/data/gsheets_set_data_validation.js';
+import { schema as gsheetsCreateFilterSchema, createFilter } from './sheets/data/gsheets_create_filter.js';
+// Formatting operations
+import { schema as gsheetsFormatCellsSchema, formatCells } from './sheets/formatting/gsheets_format_cells.js';
+import { schema as gsheetsMergeCellsSchema, mergeCells } from './sheets/formatting/gsheets_merge_cells.js';
+import { schema as gsheetsUnmergeCellsSchema, unmergeCells } from './sheets/formatting/gsheets_unmerge_cells.js';
+import { schema as gsheetsUpdateBordersSchema, updateBorders } from './sheets/formatting/gsheets_update_borders.js';
+import { schema as gsheetsAutoResizeSchema, autoResize } from './sheets/formatting/gsheets_auto_resize.js';
+import { schema as gsheetsSetNumberFormatSchema, setNumberFormat } from './sheets/formatting/gsheets_set_number_format.js';
+import { schema as gsheetsFreezeRowsSchema, freezeRows } from './sheets/formatting/gsheets_freeze_rows.js';
+import { schema as gsheetsFreezeColumnsSchema, freezeColumns } from './sheets/formatting/gsheets_freeze_columns.js';
+// Chart operations
+import { schema as gsheetsAddChartSchema, addChart } from './sheets/charts/gsheets_add_chart.js';
+import { schema as gsheetsUpdateChartSchema, updateChart } from './sheets/charts/gsheets_update_chart.js';
+import { schema as gsheetsDeleteChartSchema, deleteChart } from './sheets/charts/gsheets_delete_chart.js';
+import { schema as gsheetsAddHistogramSchema, addHistogram } from './sheets/charts/gsheets_add_histogram.js';
+import { schema as gsheetsAddWaterfallSchema, addWaterfall } from './sheets/charts/gsheets_add_waterfall.js';
+import { schema as gsheetsAddCandlestickSchema, addCandlestick } from './sheets/charts/gsheets_add_candlestick.js';
+import { schema as gsheetsAddComboSchema, addCombo } from './sheets/charts/gsheets_add_combo.js';
+import { schema as gsheetsAddBubbleSchema, addBubble } from './sheets/charts/gsheets_add_bubble.js';
+import { schema as gsheetsAddTreemapSchema, addTreemap } from './sheets/charts/gsheets_add_treemap.js';
+import { schema as gsheetsAddOrgChartSchema, addOrgChart } from './sheets/charts/gsheets_add_org_chart.js';
+// Protection operations
+import { schema as gsheetsAddProtectedRangeSchema, addProtectedRange } from './sheets/protection/gsheets_add_protected_range.js';
+import { schema as gsheetsDeleteProtectedRangeSchema, deleteProtectedRange } from './sheets/protection/gsheets_delete_protected_range.js';
+import { schema as gsheetsUpdateProtectedRangeSchema, updateProtectedRange } from './sheets/protection/gsheets_update_protected_range.js';
+import { schema as gsheetsAddNamedRangeSchema, addNamedRange } from './sheets/protection/gsheets_add_named_range.js';
+import { schema as gsheetsUpdateNamedRangeSchema, updateNamedRange } from './sheets/protection/gsheets_update_named_range.js';
+import { schema as gsheetsDeleteNamedRangeSchema, deleteNamedRange } from './sheets/protection/gsheets_delete_named_range.js';
+import { schema as gsheetsAddConditionalFormatSchema, addConditionalFormat } from './sheets/protection/gsheets_add_conditional_format.js';
+// Advanced operations
+import { schema as gsheetsAddFilterViewSchema, addFilterView } from './sheets/advanced/gsheets_add_filter_view.js';
+import { schema as gsheetsAddPivotTableSchema, addPivotTable } from './sheets/advanced/gsheets_add_pivot_table.js';
+import { schema as gsheetsAddDimensionGroupSchema, addDimensionGroup } from './sheets/advanced/gsheets_add_dimension_group.js';
+import { schema as gsheetsDeleteDimensionGroupSchema, deleteDimensionGroup } from './sheets/advanced/gsheets_delete_dimension_group.js';
+import { schema as gsheetsUpdateDimensionGroupSchema, updateDimensionGroup } from './sheets/advanced/gsheets_update_dimension_group.js';
+import { schema as gsheetsCreateDeveloperMetadataSchema, createDeveloperMetadata } from './sheets/advanced/gsheets_create_developer_metadata.js';
+import { schema as gsheetsUpdateDeveloperMetadataSchema, updateDeveloperMetadata } from './sheets/advanced/gsheets_update_developer_metadata.js';
+import { schema as gsheetsDeleteDeveloperMetadataSchema, deleteDeveloperMetadata } from './sheets/advanced/gsheets_delete_developer_metadata.js';
+export const tools = [
+    {
+        ...gdriveSearchSchema,
+        handler: search,
+    },
+    {
+        ...gdriveReadFileSchema,
+        handler: readFile,
+    },
+    {
+        ...gsheetsUpdateCellSchema,
+        handler: updateCell,
+    },
+    {
+        ...gsheetsReadSchema,
+        handler: readSheet,
+    },
+    {
+        ...gsheetsListSheetsSchema,
+        handler: listSheets,
+    },
+    {
+        ...gsheetsAddSheetSchema,
+        handler: addSheet,
+    },
+    {
+        ...gsheetsDeleteSheetSchema,
+        handler: deleteSheet,
+    },
+    {
+        ...gsheetsInsertRowsSchema,
+        handler: insertRows,
+    },
+    {
+        ...gsheetsInsertColumnsSchema,
+        handler: insertColumns,
+    },
+    {
+        ...gsheetsDeleteRowsSchema,
+        handler: deleteRows,
+    },
+    {
+        ...gsheetsDeleteColumnsSchema,
+        handler: deleteColumns,
+    },
+    {
+        ...gsheetsAppendDataSchema,
+        handler: appendData,
+    },
+    {
+        ...gsheetsBatchUpdateSchema,
+        handler: batchUpdate,
+    },
+    {
+        ...gsheetsClearDataSchema,
+        handler: clearData,
+    },
+    {
+        ...gsheetsCopySheetSchema,
+        handler: copySheet,
+    },
+    {
+        ...gsheetsCopyToSchema,
+        handler: copyTo,
+    },
+    {
+        ...gsheetsMergeCellsSchema,
+        handler: mergeCells,
+    },
+    {
+        ...gsheetsUnmergeCellsSchema,
+        handler: unmergeCells,
+    },
+    {
+        ...gsheetsUpdateBordersSchema,
+        handler: updateBorders,
+    },
+    {
+        ...gsheetsFormatCellsSchema,
+        handler: formatCells,
+    },
+    {
+        ...gsheetsSortRangeSchema,
+        handler: sortRange,
+    },
+    {
+        ...gsheetsCreateSpreadsheetSchema,
+        handler: createSpreadsheet,
+    },
+    {
+        ...gsheetsDuplicateSheetSchema,
+        handler: duplicateSheet,
+    },
+    {
+        ...gsheetsRenameSheetSchema,
+        handler: renameSheet,
+    },
+    {
+        ...gsheetsBatchClearSchema,
+        handler: batchClear,
+    },
+    {
+        ...gsheetsAutoResizeSchema,
+        handler: autoResize,
+    },
+    {
+        ...gsheetsSetNumberFormatSchema,
+        handler: setNumberFormat,
+    },
+    {
+        ...gsheetsSetDataValidationSchema,
+        handler: setDataValidation,
+    },
+    {
+        ...gsheetsAddConditionalFormatSchema,
+        handler: addConditionalFormat,
+    },
+    {
+        ...gsheetsCreateFilterSchema,
+        handler: createFilter,
+    },
+    {
+        ...gsheetsAddProtectedRangeSchema,
+        handler: addProtectedRange,
+    },
+    {
+        ...gsheetsDeleteProtectedRangeSchema,
+        handler: deleteProtectedRange,
+    },
+    {
+        ...gsheetsUpdateProtectedRangeSchema,
+        handler: updateProtectedRange,
+    },
+    {
+        ...gsheetsFindReplaceSchema,
+        handler: findReplace,
+    },
+    {
+        ...gsheetsAddNamedRangeSchema,
+        handler: addNamedRange,
+    },
+    {
+        ...gsheetsUpdateNamedRangeSchema,
+        handler: updateNamedRange,
+    },
+    {
+        ...gsheetsDeleteNamedRangeSchema,
+        handler: deleteNamedRange,
+    },
+    {
+        ...gsheetsFreezeRowsSchema,
+        handler: freezeRows,
+    },
+    {
+        ...gsheetsFreezeColumnsSchema,
+        handler: freezeColumns,
+    },
+    {
+        ...gsheetsAddChartSchema,
+        handler: addChart,
+    },
+    {
+        ...gsheetsUpdateChartSchema,
+        handler: updateChart,
+    },
+    {
+        ...gsheetsDeleteChartSchema,
+        handler: deleteChart,
+    },
+    {
+        ...gsheetsAddHistogramSchema,
+        handler: addHistogram,
+    },
+    {
+        ...gsheetsAddWaterfallSchema,
+        handler: addWaterfall,
+    },
+    {
+        ...gsheetsAddCandlestickSchema,
+        handler: addCandlestick,
+    },
+    {
+        ...gsheetsAddComboSchema,
+        handler: addCombo,
+    },
+    {
+        ...gsheetsAddBubbleSchema,
+        handler: addBubble,
+    },
+    {
+        ...gsheetsAddTreemapSchema,
+        handler: addTreemap,
+    },
+    {
+        ...gsheetsAddOrgChartSchema,
+        handler: addOrgChart,
+    },
+    {
+        ...gsheetsAddFilterViewSchema,
+        handler: addFilterView,
+    },
+    {
+        ...gsheetsAddPivotTableSchema,
+        handler: addPivotTable,
+    },
+    {
+        ...gsheetsAddDimensionGroupSchema,
+        handler: addDimensionGroup,
+    },
+    {
+        ...gsheetsDeleteDimensionGroupSchema,
+        handler: deleteDimensionGroup,
+    },
+    {
+        ...gsheetsUpdateDimensionGroupSchema,
+        handler: updateDimensionGroup,
+    },
+    {
+        ...gsheetsCreateDeveloperMetadataSchema,
+        handler: createDeveloperMetadata,
+    },
+    {
+        ...gsheetsUpdateDeveloperMetadataSchema,
+        handler: updateDeveloperMetadata,
+    },
+    {
+        ...gsheetsDeleteDeveloperMetadataSchema,
+        handler: deleteDeveloperMetadata,
+    }
+];

package/dist/tools/protection/gsheets_add_conditional_format.js

@@ -0,0 +1,175 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_add_conditional_format",
+    description: "Add conditional formatting rules to cells",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            sheetId: {
+                type: "number",
+                description: "The ID of the sheet",
+            },
+            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)",
+            },
+            rule: {
+                type: "object",
+                properties: {
+                    type: {
+                        type: "string",
+                        enum: ["NUMBER_GREATER", "NUMBER_LESS", "NUMBER_BETWEEN", "TEXT_CONTAINS", "TEXT_NOT_CONTAINS", "CUSTOM_FORMULA"],
+                        description: "The condition type",
+                    },
+                    value: {
+                        type: "string",
+                        description: "Value for comparison (for single value conditions)",
+                    },
+                    minValue: {
+                        type: "string",
+                        description: "Minimum value (for BETWEEN conditions)",
+                    },
+                    maxValue: {
+                        type: "string",
+                        description: "Maximum value (for BETWEEN conditions)",
+                    },
+                    formula: {
+                        type: "string",
+                        description: "Custom formula (for CUSTOM_FORMULA)",
+                    },
+                    backgroundColor: {
+                        type: "object",
+                        properties: {
+                            red: { type: "number", minimum: 0, maximum: 1 },
+                            green: { type: "number", minimum: 0, maximum: 1 },
+                            blue: { type: "number", minimum: 0, maximum: 1 },
+                        },
+                        description: "Background color to apply when condition is true",
+                    },
+                    textColor: {
+                        type: "object",
+                        properties: {
+                            red: { type: "number", minimum: 0, maximum: 1 },
+                            green: { type: "number", minimum: 0, maximum: 1 },
+                            blue: { type: "number", minimum: 0, maximum: 1 },
+                        },
+                        description: "Text color to apply when condition is true",
+                    },
+                    bold: {
+                        type: "boolean",
+                        description: "Make text bold when condition is true",
+                    },
+                    italic: {
+                        type: "boolean",
+                        description: "Make text italic when condition is true",
+                    },
+                },
+                required: ["type"],
+                description: "Conditional formatting rule",
+            },
+        },
+        required: ["spreadsheetId", "sheetId", "startRow", "endRow", "startColumn", "endColumn", "rule"],
+    },
+};
+export async function addConditionalFormat(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const booleanCondition = {
+            type: args.rule.type,
+        };
+        // Set condition values based on type
+        if (args.rule.type === "NUMBER_BETWEEN") {
+            booleanCondition.values = [
+                { userEnteredValue: args.rule.minValue },
+                { userEnteredValue: args.rule.maxValue },
+            ];
+        }
+        else if (args.rule.type === "CUSTOM_FORMULA") {
+            booleanCondition.values = [{ userEnteredValue: args.rule.formula }];
+        }
+        else if (args.rule.value) {
+            booleanCondition.values = [{ userEnteredValue: args.rule.value }];
+        }
+        // Build format to apply
+        const format = {};
+        if (args.rule.backgroundColor) {
+            format.backgroundColor = args.rule.backgroundColor;
+        }
+        if (args.rule.textColor || args.rule.bold || args.rule.italic) {
+            format.textFormat = {};
+            if (args.rule.textColor) {
+                format.textFormat.foregroundColor = args.rule.textColor;
+            }
+            if (args.rule.bold !== undefined) {
+                format.textFormat.bold = args.rule.bold;
+            }
+            if (args.rule.italic !== undefined) {
+                format.textFormat.italic = args.rule.italic;
+            }
+        }
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        addConditionalFormatRule: {
+                            rule: {
+                                ranges: [
+                                    {
+                                        sheetId: args.sheetId,
+                                        startRowIndex: args.startRow,
+                                        endRowIndex: args.endRow,
+                                        startColumnIndex: args.startColumn,
+                                        endColumnIndex: args.endColumn,
+                                    },
+                                ],
+                                booleanRule: {
+                                    condition: booleanCondition,
+                                    format,
+                                },
+                            },
+                            index: 0,
+                        },
+                    },
+                ],
+            },
+        });
+        const rangeStr = `R${args.startRow}C${args.startColumn}:R${args.endRow - 1}C${args.endColumn - 1}`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully added conditional formatting rule (${args.rule.type}) for range ${rangeStr}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error adding conditional format: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/protection/gsheets_add_named_range.js

@@ -0,0 +1,87 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_add_named_range",
+    description: "Create a named range in a spreadsheet",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            name: {
+                type: "string",
+                description: "The name for the range",
+            },
+            sheetId: {
+                type: "number",
+                description: "The ID of the sheet",
+            },
+            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", "name", "sheetId", "startRow", "endRow", "startColumn", "endColumn"],
+    },
+};
+export async function addNamedRange(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const response = await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        addNamedRange: {
+                            namedRange: {
+                                name: args.name,
+                                range: {
+                                    sheetId: args.sheetId,
+                                    startRowIndex: args.startRow,
+                                    endRowIndex: args.endRow,
+                                    startColumnIndex: args.startColumn,
+                                    endColumnIndex: args.endColumn,
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        const namedRangeId = response.data.replies?.[0]?.addNamedRange?.namedRange?.namedRangeId;
+        const rangeStr = `R${args.startRow}C${args.startColumn}:R${args.endRow - 1}C${args.endColumn - 1}`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully created named range "${args.name}" for ${rangeStr}. Named Range ID: ${namedRangeId}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error creating named range: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/protection/gsheets_add_protected_range.js

@@ -0,0 +1,127 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_add_protected_range",
+    description: "Add protection to a range to restrict editing",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            sheetId: {
+                type: "number",
+                description: "The ID of the sheet",
+            },
+            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)",
+            },
+            description: {
+                type: "string",
+                description: "Description of the protected range (optional)",
+            },
+            warningOnly: {
+                type: "boolean",
+                description: "If true, show a warning instead of preventing edits (default: false)",
+            },
+            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", "sheetId", "startRow", "endRow", "startColumn", "endColumn"],
+    },
+};
+export async function addProtectedRange(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const protectedRange = {
+            range: {
+                sheetId: args.sheetId,
+                startRowIndex: args.startRow,
+                endRowIndex: args.endRow,
+                startColumnIndex: args.startColumn,
+                endColumnIndex: args.endColumn,
+            },
+            warningOnly: args.warningOnly || false,
+        };
+        if (args.description) {
+            protectedRange.description = args.description;
+        }
+        if (args.editors) {
+            protectedRange.editors = {};
+            if (args.editors.users && args.editors.users.length > 0) {
+                protectedRange.editors.users = args.editors.users;
+            }
+            if (args.editors.groups && args.editors.groups.length > 0) {
+                protectedRange.editors.groups = args.editors.groups;
+            }
+            if (args.editors.domainUsersCanEdit !== undefined) {
+                protectedRange.editors.domainUsersCanEdit = args.editors.domainUsersCanEdit;
+            }
+        }
+        const response = await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        addProtectedRange: {
+                            protectedRange,
+                        },
+                    },
+                ],
+            },
+        });
+        const addedProtection = response.data.replies?.[0]?.addProtectedRange?.protectedRange;
+        const rangeStr = `R${args.startRow}C${args.startColumn}:R${args.endRow - 1}C${args.endColumn - 1}`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully added protection to range ${rangeStr}. Protection ID: ${addedProtection?.protectedRangeId}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error adding protected range: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}