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

package/dist/tools/gsheets_merge_cells.js

@@ -1,85 +0,0 @@
-import { google } from "googleapis";
-export const schema = {
-    name: "gsheets_merge_cells",
-    description: "Merge cells 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)",
-            },
-            mergeType: {
-                type: "string",
-                enum: ["MERGE_ALL", "MERGE_COLUMNS", "MERGE_ROWS"],
-                description: "How to merge cells: MERGE_ALL (all cells), MERGE_COLUMNS (merge columns), MERGE_ROWS (merge rows)",
-            },
-        },
-        required: ["spreadsheetId", "sheetId", "startRow", "endRow", "startColumn", "endColumn"],
-    },
-};
-export async function mergeCells(args) {
-    try {
-        const sheets = google.sheets("v4");
-        await sheets.spreadsheets.batchUpdate({
-            spreadsheetId: args.spreadsheetId,
-            requestBody: {
-                requests: [
-                    {
-                        mergeCells: {
-                            range: {
-                                sheetId: args.sheetId,
-                                startRowIndex: args.startRow,
-                                endRowIndex: args.endRow,
-                                startColumnIndex: args.startColumn,
-                                endColumnIndex: args.endColumn,
-                            },
-                            mergeType: args.mergeType || "MERGE_ALL",
-                        },
-                    },
-                ],
-            },
-        });
-        const rangeStr = `R${args.startRow}C${args.startColumn}:R${args.endRow - 1}C${args.endColumn - 1}`;
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Successfully merged cells in range ${rangeStr} using ${args.mergeType || "MERGE_ALL"} mode`,
-                },
-            ],
-            isError: false,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error merging cells: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}

package/dist/tools/gsheets_read.js

@@ -1,120 +0,0 @@
-import { google } from "googleapis";
-export const schema = {
-    name: "gsheets_read",
-    description: "Read data from a Google Spreadsheet with flexible options for ranges and formatting",
-    inputSchema: {
-        type: "object",
-        properties: {
-            spreadsheetId: {
-                type: "string",
-                description: "The ID of the spreadsheet to read",
-            },
-            ranges: {
-                type: "array",
-                items: {
-                    type: "string",
-                },
-                description: "Optional array of A1 notation ranges like ['Sheet1!A1:B10']. If not provided, reads entire sheet.",
-            },
-            sheetId: {
-                type: "number",
-                description: "Optional specific sheet ID to read. If not provided with ranges, reads first sheet.",
-            },
-        },
-        required: ["spreadsheetId"],
-    },
-};
-const sheets = google.sheets("v4");
-function getA1Notation(row, col) {
-    let a1 = "";
-    while (col > 0) {
-        col--;
-        a1 = String.fromCharCode(65 + (col % 26)) + a1;
-        col = Math.floor(col / 26);
-    }
-    return `${a1}${row + 1}`;
-}
-async function processSheetData(response) {
-    const results = [];
-    // Handle both single and multiple ranges
-    const valueRanges = response.data.valueRanges || [response.data];
-    for (const range of valueRanges) {
-        const values = range.values || [];
-        if (values.length === 0)
-            continue;
-        // Extract sheet name from range
-        const rangeParts = range.range?.split("!") || [];
-        const sheetName = rangeParts[0]?.replace(/'/g, "") || "Sheet1";
-        // Process data with cell locations
-        const processedValues = values.map((row, rowIndex) => row.map((cell, colIndex) => ({
-            value: cell,
-            location: `${sheetName}!${getA1Notation(rowIndex, colIndex + 1)}`,
-        })));
-        // Process headers with locations
-        const columnHeaders = processedValues[0];
-        const data = processedValues.slice(1);
-        results.push({
-            sheetName,
-            data,
-            totalRows: values.length,
-            totalColumns: columnHeaders.length,
-            columnHeaders,
-        });
-    }
-    return results;
-}
-export async function readSheet(args) {
-    try {
-        let response;
-        if (args.ranges) {
-            // Read specific ranges
-            response = await sheets.spreadsheets.values.batchGet({
-                spreadsheetId: args.spreadsheetId,
-                ranges: args.ranges,
-            });
-        }
-        else if (args.sheetId !== undefined) {
-            // Get sheet name from sheet ID first
-            const metadata = await sheets.spreadsheets.get({
-                spreadsheetId: args.spreadsheetId,
-                fields: "sheets.properties",
-            });
-            const sheet = metadata.data.sheets?.find((s) => s.properties?.sheetId === args.sheetId);
-            if (!sheet?.properties?.title) {
-                throw new Error(`Sheet ID ${args.sheetId} not found`);
-            }
-            response = await sheets.spreadsheets.values.get({
-                spreadsheetId: args.spreadsheetId,
-                range: sheet.properties.title,
-            });
-        }
-        else {
-            // Read first sheet by default
-            response = await sheets.spreadsheets.values.get({
-                spreadsheetId: args.spreadsheetId,
-                range: "A:ZZ", // Read all possible columns
-            });
-        }
-        const processedData = await processSheetData(response);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(processedData, null, 2),
-                },
-            ],
-            isError: false,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error reading spreadsheet: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}

package/dist/tools/gsheets_rename_sheet.js

@@ -1,64 +0,0 @@
-import { google } from "googleapis";
-export const schema = {
-    name: "gsheets_rename_sheet",
-    description: "Rename a sheet 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 to rename",
-            },
-            newTitle: {
-                type: "string",
-                description: "The new title for the sheet",
-            },
-        },
-        required: ["spreadsheetId", "sheetId", "newTitle"],
-    },
-};
-export async function renameSheet(args) {
-    try {
-        const sheets = google.sheets("v4");
-        await sheets.spreadsheets.batchUpdate({
-            spreadsheetId: args.spreadsheetId,
-            requestBody: {
-                requests: [
-                    {
-                        updateSheetProperties: {
-                            properties: {
-                                sheetId: args.sheetId,
-                                title: args.newTitle,
-                            },
-                            fields: "title",
-                        },
-                    },
-                ],
-            },
-        });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Successfully renamed sheet ${args.sheetId} to "${args.newTitle}"`,
-                },
-            ],
-            isError: false,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error renaming sheet: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}

package/dist/tools/gsheets_set_data_validation.js

@@ -1,153 +0,0 @@
-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/gsheets_set_number_format.js

@@ -1,116 +0,0 @@
-import { google } from "googleapis";
-export const schema = {
-    name: "gsheets_set_number_format",
-    description: "Set number format for cells (currency, percentage, date, 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)",
-            },
-            numberFormat: {
-                type: "object",
-                properties: {
-                    type: {
-                        type: "string",
-                        enum: ["NUMBER", "CURRENCY", "PERCENT", "DATE", "TIME", "DATE_TIME", "SCIENTIFIC", "TEXT"],
-                        description: "The type of number format",
-                    },
-                    pattern: {
-                        type: "string",
-                        description: "Custom format pattern (optional, e.g., '$#,##0.00', '0.00%', 'yyyy-mm-dd')",
-                    },
-                },
-                required: ["type"],
-                description: "Number format settings",
-            },
-        },
-        required: ["spreadsheetId", "sheetId", "startRow", "endRow", "startColumn", "endColumn", "numberFormat"],
-    },
-};
-export async function setNumberFormat(args) {
-    try {
-        const sheets = google.sheets("v4");
-        // Default patterns for common types
-        const defaultPatterns = {
-            NUMBER: "#,##0.00",
-            CURRENCY: "$#,##0.00",
-            PERCENT: "0.00%",
-            DATE: "yyyy-mm-dd",
-            TIME: "h:mm:ss",
-            DATE_TIME: "yyyy-mm-dd h:mm:ss",
-            SCIENTIFIC: "0.00E+00",
-            TEXT: "@",
-        };
-        const pattern = args.numberFormat.pattern || defaultPatterns[args.numberFormat.type];
-        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: {
-                                    numberFormat: {
-                                        type: args.numberFormat.type,
-                                        pattern: pattern,
-                                    },
-                                },
-                            },
-                            fields: "userEnteredFormat.numberFormat",
-                        },
-                    },
-                ],
-            },
-        });
-        const rangeStr = `R${args.startRow}C${args.startColumn}:R${args.endRow - 1}C${args.endColumn - 1}`;
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Successfully set number format to ${args.numberFormat.type} (pattern: ${pattern}) for range ${rangeStr}`,
-                },
-            ],
-            isError: false,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error setting number format: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}

package/dist/tools/gsheets_sort_range.js

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