@alanse/mcp-server-google-workspace 0.2.0

package/dist/tools/sheets/charts/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/sheets/charts/gsheets_delete_chart.js

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

package/dist/tools/sheets/charts/gsheets_update_chart.js

@@ -0,0 +1,118 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_update_chart",
+    description: "Update an existing chart's properties",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            chartId: {
+                type: "number",
+                description: "The ID of the chart to update",
+            },
+            title: {
+                type: "string",
+                description: "New chart title (optional)",
+            },
+            position: {
+                type: "object",
+                properties: {
+                    sheetId: {
+                        type: "number",
+                        description: "Sheet ID for chart position",
+                    },
+                    overlayRow: {
+                        type: "number",
+                        description: "Row position for chart overlay (0-based)",
+                    },
+                    overlayColumn: {
+                        type: "number",
+                        description: "Column position for chart overlay (0-based)",
+                    },
+                },
+                description: "New chart position (optional)",
+            },
+        },
+        required: ["spreadsheetId", "chartId"],
+    },
+};
+export async function updateChart(args) {
+    try {
+        const sheets = google.sheets("v4");
+        // First, get the current chart to preserve properties we're not updating
+        const spreadsheet = await sheets.spreadsheets.get({
+            spreadsheetId: args.spreadsheetId,
+        });
+        let currentChart = null;
+        for (const sheet of spreadsheet.data.sheets || []) {
+            const chart = sheet.charts?.find((c) => c.chartId === args.chartId);
+            if (chart) {
+                currentChart = chart;
+                break;
+            }
+        }
+        if (!currentChart) {
+            throw new Error(`Chart ${args.chartId} not found`);
+        }
+        const updatedChart = {
+            chartId: args.chartId,
+            spec: currentChart.spec,
+            position: currentChart.position,
+        };
+        const fields = [];
+        // Update title if provided
+        if (args.title !== undefined) {
+            updatedChart.spec.title = args.title;
+            fields.push("spec.title");
+        }
+        // Update position if provided
+        if (args.position) {
+            updatedChart.position = {
+                overlayPosition: {
+                    anchorCell: {
+                        sheetId: args.position.sheetId,
+                        rowIndex: args.position.overlayRow || 0,
+                        columnIndex: args.position.overlayColumn || 0,
+                    },
+                },
+            };
+            fields.push("position");
+        }
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        updateChartSpec: {
+                            chartId: args.chartId,
+                            spec: updatedChart.spec,
+                        },
+                    },
+                ],
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully updated chart ${args.chartId}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error updating chart: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/sheets/data/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/sheets/data/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/sheets/data/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/sheets/data/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/sheets/data/gsheets_create_filter.js

@@ -0,0 +1,81 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_create_filter",
+    description: "Create a basic filter for a range 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)",
+            },
+        },
+        required: ["spreadsheetId", "sheetId", "startRow", "endRow", "startColumn", "endColumn"],
+    },
+};
+export async function createFilter(args) {
+    try {
+        const sheets = google.sheets("v4");
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        setBasicFilter: {
+                            filter: {
+                                range: {
+                                    sheetId: args.sheetId,
+                                    startRowIndex: args.startRow,
+                                    endRowIndex: args.endRow,
+                                    startColumnIndex: args.startColumn,
+                                    endColumnIndex: args.endColumn,
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        const rangeStr = `R${args.startRow}C${args.startColumn}:R${args.endRow - 1}C${args.endColumn - 1}`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully created filter for range ${rangeStr}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error creating filter: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}