@alanse/mcp-server-google-workspace 0.2.0

package/dist/tools/gsheets_add_waterfall.js

@@ -0,0 +1,155 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_add_waterfall",
+    description: "Add a waterfall chart to a spreadsheet",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            sheetId: {
+                type: "number",
+                description: "The ID of the sheet where the chart will be placed",
+            },
+            title: {
+                type: "string",
+                description: "Chart title (optional)",
+            },
+            dataSheetId: {
+                type: "number",
+                description: "The sheet ID containing the data",
+            },
+            dataStartRow: {
+                type: "number",
+                description: "Starting row of data range (0-based)",
+            },
+            dataEndRow: {
+                type: "number",
+                description: "Ending row of data range (exclusive, 0-based)",
+            },
+            dataStartColumn: {
+                type: "number",
+                description: "Starting column of data range (0-based)",
+            },
+            dataEndColumn: {
+                type: "number",
+                description: "Ending column of data range (exclusive, 0-based)",
+            },
+            firstValueIsTotal: {
+                type: "boolean",
+                description: "Whether the first value should be treated as a total (optional)",
+            },
+            hideConnectorLines: {
+                type: "boolean",
+                description: "Whether to hide connector lines (optional)",
+            },
+            position: {
+                type: "object",
+                properties: {
+                    overlayRow: {
+                        type: "number",
+                        description: "Row position for chart overlay (0-based)",
+                    },
+                    overlayColumn: {
+                        type: "number",
+                        description: "Column position for chart overlay (0-based)",
+                    },
+                },
+                description: "Chart position (optional)",
+            },
+        },
+        required: ["spreadsheetId", "sheetId", "dataSheetId", "dataStartRow", "dataEndRow", "dataStartColumn", "dataEndColumn"],
+    },
+};
+export async function addWaterfall(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const waterfallChart = {
+            series: [
+                {
+                    sourceRange: {
+                        sources: [
+                            {
+                                sheetId: args.dataSheetId,
+                                startRowIndex: args.dataStartRow,
+                                endRowIndex: args.dataEndRow,
+                                startColumnIndex: args.dataStartColumn + 1,
+                                endColumnIndex: args.dataEndColumn,
+                            },
+                        ],
+                    },
+                },
+            ],
+            domain: {
+                sourceRange: {
+                    sources: [
+                        {
+                            sheetId: args.dataSheetId,
+                            startRowIndex: args.dataStartRow,
+                            endRowIndex: args.dataEndRow,
+                            startColumnIndex: args.dataStartColumn,
+                            endColumnIndex: args.dataStartColumn + 1,
+                        },
+                    ],
+                },
+            },
+        };
+        if (args.firstValueIsTotal !== undefined) {
+            waterfallChart.firstValueIsTotal = args.firstValueIsTotal;
+        }
+        if (args.hideConnectorLines !== undefined) {
+            waterfallChart.hideConnectorLines = args.hideConnectorLines;
+        }
+        const chartSpec = {
+            title: args.title || "Waterfall Chart",
+            waterfallChart,
+        };
+        const position = {
+            overlayPosition: {
+                anchorCell: {
+                    sheetId: args.sheetId,
+                    rowIndex: args.position?.overlayRow || 0,
+                    columnIndex: args.position?.overlayColumn || 0,
+                },
+            },
+        };
+        const response = await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        addChart: {
+                            chart: {
+                                spec: chartSpec,
+                                position,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        const chartId = response.data.replies?.[0]?.addChart?.chart?.chartId;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully created waterfall chart. Chart ID: ${chartId}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error creating waterfall chart: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/gsheets_append_data.js

@@ -0,0 +1,68 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_append_data",
+    description: "Append data to the end of a sheet in a Google Spreadsheet",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            range: {
+                type: "string",
+                description: "The A1 notation range to append to (e.g., 'Sheet1!A:B')",
+            },
+            values: {
+                type: "array",
+                items: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                    },
+                },
+                description: "2D array of values to append",
+            },
+            valueInputOption: {
+                type: "string",
+                enum: ["RAW", "USER_ENTERED"],
+                description: "How input data should be interpreted (RAW or USER_ENTERED). Default: RAW",
+            },
+        },
+        required: ["spreadsheetId", "range", "values"],
+    },
+};
+export async function appendData(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const response = await sheets.spreadsheets.values.append({
+            spreadsheetId: args.spreadsheetId,
+            range: args.range,
+            valueInputOption: args.valueInputOption || "RAW",
+            requestBody: {
+                values: args.values,
+            },
+        });
+        const updates = response.data.updates;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully appended ${updates?.updatedRows || 0} row(s) and ${updates?.updatedColumns || 0} column(s) to range ${updates?.updatedRange}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error appending data: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/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/gsheets_batch_clear.js

@@ -0,0 +1,53 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_batch_clear",
+    description: "Clear data from multiple ranges in a Google Spreadsheet",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            ranges: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+                description: "Array of A1 notation ranges to clear (e.g., ['Sheet1!A1:B10', 'Sheet2!C5:D20'])",
+            },
+        },
+        required: ["spreadsheetId", "ranges"],
+    },
+};
+export async function batchClear(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const response = await sheets.spreadsheets.values.batchClear({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                ranges: args.ranges,
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully cleared ${args.ranges.length} range(s): ${args.ranges.join(", ")}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error clearing ranges: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/gsheets_batch_update.js

@@ -0,0 +1,81 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_batch_update",
+    description: "Update multiple cell ranges in a Google Spreadsheet in a single batch operation",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            updates: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        range: {
+                            type: "string",
+                            description: "The A1 notation range (e.g., 'Sheet1!A1:B2')",
+                        },
+                        values: {
+                            type: "array",
+                            items: {
+                                type: "array",
+                                items: {
+                                    type: "string",
+                                },
+                            },
+                            description: "2D array of values",
+                        },
+                    },
+                    required: ["range", "values"],
+                },
+                description: "Array of range-value pairs to update",
+            },
+            valueInputOption: {
+                type: "string",
+                enum: ["RAW", "USER_ENTERED"],
+                description: "How input data should be interpreted (RAW or USER_ENTERED). Default: RAW",
+            },
+        },
+        required: ["spreadsheetId", "updates"],
+    },
+};
+export async function batchUpdate(args) {
+    const sheets = google.sheets("v4");
+    try {
+        const response = await sheets.spreadsheets.values.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                valueInputOption: args.valueInputOption || "RAW",
+                data: args.updates.map((update) => ({
+                    range: update.range,
+                    values: update.values,
+                })),
+            },
+        });
+        const totalRows = response.data.totalUpdatedRows || 0;
+        const totalCells = response.data.totalUpdatedCells || 0;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully updated ${args.updates.length} range(s): ${totalRows} row(s), ${totalCells} cell(s) modified`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error batch updating: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/gsheets_clear_data.js

@@ -0,0 +1,53 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_clear_data",
+    description: "Clear data from specified ranges in a Google Spreadsheet",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            ranges: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+                description: "Array of A1 notation ranges to clear (e.g., ['Sheet1!A1:B10', 'Sheet2!C1:D5'])",
+            },
+        },
+        required: ["spreadsheetId", "ranges"],
+    },
+};
+export async function clearData(args) {
+    const sheets = google.sheets("v4");
+    try {
+        const response = await sheets.spreadsheets.values.batchClear({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                ranges: args.ranges,
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully cleared ${args.ranges.length} range(s): ${args.ranges.join(", ")}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error clearing data: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/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/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,
+        };
+    }
+}