@alanse/mcp-server-google-workspace 0.2.0

package/dist/tools/data/gsheets_find_replace.js

@@ -0,0 +1,124 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_find_replace",
+    description: "Find and replace text in a range or entire sheet",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            sheetId: {
+                type: "number",
+                description: "The ID of the sheet (optional, searches all sheets if omitted)",
+            },
+            find: {
+                type: "string",
+                description: "Text to find",
+            },
+            replacement: {
+                type: "string",
+                description: "Replacement text",
+            },
+            matchCase: {
+                type: "boolean",
+                description: "Case-sensitive matching (default: false)",
+            },
+            matchEntireCell: {
+                type: "boolean",
+                description: "Match entire cell content (default: false)",
+            },
+            searchByRegex: {
+                type: "boolean",
+                description: "Use regex pattern (default: false)",
+            },
+            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", "find", "replacement"],
+    },
+};
+export async function findReplace(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const findReplaceSpec = {
+            find: args.find,
+            replacement: args.replacement,
+            matchCase: args.matchCase || false,
+            matchEntireCell: args.matchEntireCell || false,
+            searchByRegex: args.searchByRegex || false,
+        };
+        // Add range if specified
+        if (args.sheetId !== undefined ||
+            args.startRow !== undefined ||
+            args.endRow !== undefined ||
+            args.startColumn !== undefined ||
+            args.endColumn !== undefined) {
+            findReplaceSpec.range = {};
+            if (args.sheetId !== undefined) {
+                findReplaceSpec.range.sheetId = args.sheetId;
+            }
+            if (args.startRow !== undefined) {
+                findReplaceSpec.range.startRowIndex = args.startRow;
+            }
+            if (args.endRow !== undefined) {
+                findReplaceSpec.range.endRowIndex = args.endRow;
+            }
+            if (args.startColumn !== undefined) {
+                findReplaceSpec.range.startColumnIndex = args.startColumn;
+            }
+            if (args.endColumn !== undefined) {
+                findReplaceSpec.range.endColumnIndex = args.endColumn;
+            }
+        }
+        const response = await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        findReplace: findReplaceSpec,
+                    },
+                ],
+            },
+        });
+        const occurrencesChanged = response.data.replies?.[0]?.findReplace?.occurrencesChanged || 0;
+        const rowsChanged = response.data.replies?.[0]?.findReplace?.rowsChanged || 0;
+        const sheetsChanged = response.data.replies?.[0]?.findReplace?.sheetsChanged || 0;
+        const valuesChanged = response.data.replies?.[0]?.findReplace?.valuesChanged || 0;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully replaced "${args.find}" with "${args.replacement}". Changed: ${occurrencesChanged} occurrences, ${rowsChanged} rows, ${sheetsChanged} sheets, ${valuesChanged} values.`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error finding and replacing: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/data/gsheets_set_data_validation.js

@@ -0,0 +1,153 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_set_data_validation",
+    description: "Set data validation rules for cells (dropdowns, number ranges, etc.)",
+    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)",
+            },
+            validation: {
+                type: "object",
+                properties: {
+                    type: {
+                        type: "string",
+                        enum: ["ONE_OF_LIST", "ONE_OF_RANGE", "NUMBER_GREATER", "NUMBER_LESS", "NUMBER_BETWEEN", "DATE_AFTER", "DATE_BEFORE", "CUSTOM_FORMULA"],
+                        description: "The type of data validation",
+                    },
+                    values: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "List of valid values (for ONE_OF_LIST)",
+                    },
+                    minValue: {
+                        type: "string",
+                        description: "Minimum value (for NUMBER_BETWEEN, NUMBER_GREATER)",
+                    },
+                    maxValue: {
+                        type: "string",
+                        description: "Maximum value (for NUMBER_BETWEEN, NUMBER_LESS)",
+                    },
+                    formula: {
+                        type: "string",
+                        description: "Custom formula (for CUSTOM_FORMULA)",
+                    },
+                    strict: {
+                        type: "boolean",
+                        description: "Whether to reject input when validation fails (default: true)",
+                    },
+                    showCustomUi: {
+                        type: "boolean",
+                        description: "Show dropdown for list validation (default: true)",
+                    },
+                },
+                required: ["type"],
+                description: "Data validation settings",
+            },
+        },
+        required: ["spreadsheetId", "sheetId", "startRow", "endRow", "startColumn", "endColumn", "validation"],
+    },
+};
+export async function setDataValidation(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const condition = {};
+        switch (args.validation.type) {
+            case "ONE_OF_LIST":
+                if (!args.validation.values || args.validation.values.length === 0) {
+                    throw new Error("values array is required for ONE_OF_LIST validation");
+                }
+                condition.type = "ONE_OF_LIST";
+                condition.values = args.validation.values.map(v => ({ userEnteredValue: v }));
+                break;
+            case "NUMBER_GREATER":
+                condition.type = "NUMBER_GREATER";
+                condition.values = [{ userEnteredValue: args.validation.minValue }];
+                break;
+            case "NUMBER_LESS":
+                condition.type = "NUMBER_LESS";
+                condition.values = [{ userEnteredValue: args.validation.maxValue }];
+                break;
+            case "NUMBER_BETWEEN":
+                condition.type = "NUMBER_BETWEEN";
+                condition.values = [
+                    { userEnteredValue: args.validation.minValue },
+                    { userEnteredValue: args.validation.maxValue },
+                ];
+                break;
+            case "CUSTOM_FORMULA":
+                condition.type = "CUSTOM_FORMULA";
+                condition.values = [{ userEnteredValue: args.validation.formula }];
+                break;
+            default:
+                condition.type = args.validation.type;
+        }
+        const rule = {
+            condition,
+            strict: args.validation.strict !== false,
+            showCustomUi: args.validation.showCustomUi !== false,
+        };
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        setDataValidation: {
+                            range: {
+                                sheetId: args.sheetId,
+                                startRowIndex: args.startRow,
+                                endRowIndex: args.endRow,
+                                startColumnIndex: args.startColumn,
+                                endColumnIndex: args.endColumn,
+                            },
+                            rule,
+                        },
+                    },
+                ],
+            },
+        });
+        const rangeStr = `R${args.startRow}C${args.startColumn}:R${args.endRow - 1}C${args.endColumn - 1}`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully set data validation (${args.validation.type}) for range ${rangeStr}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error setting data validation: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/data/gsheets_sort_range.js

@@ -0,0 +1,102 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_sort_range",
+    description: "Sort a range of data in a Google Spreadsheet",
+    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)",
+            },
+            sortSpecs: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        dimensionIndex: {
+                            type: "number",
+                            description: "Column index to sort by (0-based)",
+                        },
+                        sortOrder: {
+                            type: "string",
+                            enum: ["ASCENDING", "DESCENDING"],
+                            description: "Sort order",
+                        },
+                    },
+                    required: ["dimensionIndex", "sortOrder"],
+                },
+                description: "Sort specifications (multiple for multi-level sorting)",
+            },
+        },
+        required: ["spreadsheetId", "sheetId", "startRow", "endRow", "startColumn", "endColumn", "sortSpecs"],
+    },
+};
+export async function sortRange(args) {
+    try {
+        const sheets = google.sheets("v4");
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        sortRange: {
+                            range: {
+                                sheetId: args.sheetId,
+                                startRowIndex: args.startRow,
+                                endRowIndex: args.endRow,
+                                startColumnIndex: args.startColumn,
+                                endColumnIndex: args.endColumn,
+                            },
+                            sortSpecs: args.sortSpecs,
+                        },
+                    },
+                ],
+            },
+        });
+        const rangeStr = `R${args.startRow}C${args.startColumn}:R${args.endRow - 1}C${args.endColumn - 1}`;
+        const sortDesc = args.sortSpecs
+            .map((spec) => `column ${spec.dimensionIndex} (${spec.sortOrder})`)
+            .join(", ");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully sorted range ${rangeStr} by ${sortDesc}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error sorting range: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/data/gsheets_update_cell.js

@@ -0,0 +1,44 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_update_cell",
+    description: "Update a cell value in a Google Spreadsheet",
+    inputSchema: {
+        type: "object",
+        properties: {
+            fileId: {
+                type: "string",
+                description: "ID of the spreadsheet",
+            },
+            range: {
+                type: "string",
+                description: "Cell range in A1 notation (e.g. 'Sheet1!A1')",
+            },
+            value: {
+                type: "string",
+                description: "New cell value",
+            },
+        },
+        required: ["fileId", "range", "value"],
+    },
+};
+export async function updateCell(args) {
+    const { fileId, range, value } = args;
+    const sheets = google.sheets({ version: "v4" });
+    await sheets.spreadsheets.values.update({
+        spreadsheetId: fileId,
+        range: range,
+        valueInputOption: "RAW",
+        requestBody: {
+            values: [[value]],
+        },
+    });
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Updated cell ${range} to value: ${value}`,
+            },
+        ],
+        isError: false,
+    };
+}

package/dist/tools/formatting/gsheets_auto_resize.js

@@ -0,0 +1,75 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_auto_resize",
+    description: "Automatically resize rows or columns to fit content",
+    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: "Whether to resize rows or columns",
+            },
+            startIndex: {
+                type: "number",
+                description: "The starting index (0-based) of rows/columns to resize",
+            },
+            endIndex: {
+                type: "number",
+                description: "The ending index (exclusive, 0-based) of rows/columns to resize",
+            },
+        },
+        required: ["spreadsheetId", "sheetId", "dimension", "startIndex", "endIndex"],
+    },
+};
+export async function autoResize(args) {
+    try {
+        const sheets = google.sheets("v4");
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        autoResizeDimensions: {
+                            dimensions: {
+                                sheetId: args.sheetId,
+                                dimension: args.dimension,
+                                startIndex: args.startIndex,
+                                endIndex: args.endIndex,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        const count = args.endIndex - args.startIndex;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully auto-resized ${count} ${args.dimension.toLowerCase()} (indices ${args.startIndex}-${args.endIndex - 1})`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error auto-resizing: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/formatting/gsheets_format_cells.js

@@ -0,0 +1,161 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_format_cells",
+    description: "Format cells in a Google Spreadsheet (font, colors, alignment, etc.)",
+    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)",
+            },
+            format: {
+                type: "object",
+                properties: {
+                    bold: { type: "boolean", description: "Make text bold" },
+                    italic: { type: "boolean", description: "Make text italic" },
+                    fontSize: { type: "number", description: "Font size in points" },
+                    fontFamily: { type: "string", description: "Font family name" },
+                    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 (RGB values 0-1)",
+                    },
+                    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 (RGB values 0-1)",
+                    },
+                    horizontalAlignment: {
+                        type: "string",
+                        enum: ["LEFT", "CENTER", "RIGHT"],
+                        description: "Horizontal text alignment",
+                    },
+                    verticalAlignment: {
+                        type: "string",
+                        enum: ["TOP", "MIDDLE", "BOTTOM"],
+                        description: "Vertical text alignment",
+                    },
+                },
+                description: "Format options to apply",
+            },
+        },
+        required: ["spreadsheetId", "sheetId", "startRow", "endRow", "startColumn", "endColumn", "format"],
+    },
+};
+export async function formatCells(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const cellFormat = {};
+        const fields = [];
+        if (args.format.bold !== undefined || args.format.italic !== undefined ||
+            args.format.fontSize !== undefined || args.format.fontFamily !== undefined ||
+            args.format.textColor !== undefined) {
+            cellFormat.textFormat = {};
+            if (args.format.bold !== undefined) {
+                cellFormat.textFormat.bold = args.format.bold;
+                fields.push("userEnteredFormat.textFormat.bold");
+            }
+            if (args.format.italic !== undefined) {
+                cellFormat.textFormat.italic = args.format.italic;
+                fields.push("userEnteredFormat.textFormat.italic");
+            }
+            if (args.format.fontSize !== undefined) {
+                cellFormat.textFormat.fontSize = args.format.fontSize;
+                fields.push("userEnteredFormat.textFormat.fontSize");
+            }
+            if (args.format.fontFamily !== undefined) {
+                cellFormat.textFormat.fontFamily = args.format.fontFamily;
+                fields.push("userEnteredFormat.textFormat.fontFamily");
+            }
+            if (args.format.textColor !== undefined) {
+                cellFormat.textFormat.foregroundColor = args.format.textColor;
+                fields.push("userEnteredFormat.textFormat.foregroundColor");
+            }
+        }
+        if (args.format.backgroundColor !== undefined) {
+            cellFormat.backgroundColor = args.format.backgroundColor;
+            fields.push("userEnteredFormat.backgroundColor");
+        }
+        if (args.format.horizontalAlignment !== undefined) {
+            cellFormat.horizontalAlignment = args.format.horizontalAlignment;
+            fields.push("userEnteredFormat.horizontalAlignment");
+        }
+        if (args.format.verticalAlignment !== undefined) {
+            cellFormat.verticalAlignment = args.format.verticalAlignment;
+            fields.push("userEnteredFormat.verticalAlignment");
+        }
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        repeatCell: {
+                            range: {
+                                sheetId: args.sheetId,
+                                startRowIndex: args.startRow,
+                                endRowIndex: args.endRow,
+                                startColumnIndex: args.startColumn,
+                                endColumnIndex: args.endColumn,
+                            },
+                            cell: {
+                                userEnteredFormat: cellFormat,
+                            },
+                            fields: fields.join(","),
+                        },
+                    },
+                ],
+            },
+        });
+        const rangeStr = `R${args.startRow}C${args.startColumn}:R${args.endRow - 1}C${args.endColumn - 1}`;
+        const appliedFormats = Object.keys(args.format).join(", ");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully formatted cells in range ${rangeStr}. Applied formats: ${appliedFormats}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error formatting cells: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}