@alanse/mcp-server-google-workspace 1.0.0 → 1.0.2

package/dist/tools/gsheets_add_waterfall.js

@@ -1,155 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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,
-        };
-    }
-}