@alanse/mcp-server-google-workspace 0.2.0

package/dist/tools/gsheets_unmerge_cells.js

@@ -0,0 +1,79 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_unmerge_cells",
+    description: "Unmerge previously merged 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)",
+            },
+        },
+        required: ["spreadsheetId", "sheetId", "startRow", "endRow", "startColumn", "endColumn"],
+    },
+};
+export async function unmergeCells(args) {
+    try {
+        const sheets = google.sheets("v4");
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        unmergeCells: {
+                            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 unmerged cells in range ${rangeStr}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error unmerging cells: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/gsheets_update_borders.js

@@ -0,0 +1,212 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_update_borders",
+    description: "Update cell borders 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)",
+            },
+            top: {
+                type: "object",
+                properties: {
+                    style: {
+                        type: "string",
+                        enum: ["SOLID", "DOTTED", "DASHED", "DOUBLE", "SOLID_MEDIUM", "SOLID_THICK"],
+                    },
+                    width: { type: "number" },
+                    color: {
+                        type: "object",
+                        properties: {
+                            red: { type: "number" },
+                            green: { type: "number" },
+                            blue: { type: "number" },
+                        },
+                    },
+                },
+                description: "Top border style",
+            },
+            bottom: {
+                type: "object",
+                properties: {
+                    style: {
+                        type: "string",
+                        enum: ["SOLID", "DOTTED", "DASHED", "DOUBLE", "SOLID_MEDIUM", "SOLID_THICK"],
+                    },
+                    width: { type: "number" },
+                    color: {
+                        type: "object",
+                        properties: {
+                            red: { type: "number" },
+                            green: { type: "number" },
+                            blue: { type: "number" },
+                        },
+                    },
+                },
+                description: "Bottom border style",
+            },
+            left: {
+                type: "object",
+                properties: {
+                    style: {
+                        type: "string",
+                        enum: ["SOLID", "DOTTED", "DASHED", "DOUBLE", "SOLID_MEDIUM", "SOLID_THICK"],
+                    },
+                    width: { type: "number" },
+                    color: {
+                        type: "object",
+                        properties: {
+                            red: { type: "number" },
+                            green: { type: "number" },
+                            blue: { type: "number" },
+                        },
+                    },
+                },
+                description: "Left border style",
+            },
+            right: {
+                type: "object",
+                properties: {
+                    style: {
+                        type: "string",
+                        enum: ["SOLID", "DOTTED", "DASHED", "DOUBLE", "SOLID_MEDIUM", "SOLID_THICK"],
+                    },
+                    width: { type: "number" },
+                    color: {
+                        type: "object",
+                        properties: {
+                            red: { type: "number" },
+                            green: { type: "number" },
+                            blue: { type: "number" },
+                        },
+                    },
+                },
+                description: "Right border style",
+            },
+            innerHorizontal: {
+                type: "object",
+                properties: {
+                    style: {
+                        type: "string",
+                        enum: ["SOLID", "DOTTED", "DASHED", "DOUBLE", "SOLID_MEDIUM", "SOLID_THICK"],
+                    },
+                    width: { type: "number" },
+                    color: {
+                        type: "object",
+                        properties: {
+                            red: { type: "number" },
+                            green: { type: "number" },
+                            blue: { type: "number" },
+                        },
+                    },
+                },
+                description: "Inner horizontal border style",
+            },
+            innerVertical: {
+                type: "object",
+                properties: {
+                    style: {
+                        type: "string",
+                        enum: ["SOLID", "DOTTED", "DASHED", "DOUBLE", "SOLID_MEDIUM", "SOLID_THICK"],
+                    },
+                    width: { type: "number" },
+                    color: {
+                        type: "object",
+                        properties: {
+                            red: { type: "number" },
+                            green: { type: "number" },
+                            blue: { type: "number" },
+                        },
+                    },
+                },
+                description: "Inner vertical border style",
+            },
+        },
+        required: ["spreadsheetId", "sheetId", "startRow", "endRow", "startColumn", "endColumn"],
+    },
+};
+export async function updateBorders(args) {
+    try {
+        const sheets = google.sheets("v4");
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        updateBorders: {
+                            range: {
+                                sheetId: args.sheetId,
+                                startRowIndex: args.startRow,
+                                endRowIndex: args.endRow,
+                                startColumnIndex: args.startColumn,
+                                endColumnIndex: args.endColumn,
+                            },
+                            top: args.top,
+                            bottom: args.bottom,
+                            left: args.left,
+                            right: args.right,
+                            innerHorizontal: args.innerHorizontal,
+                            innerVertical: args.innerVertical,
+                        },
+                    },
+                ],
+            },
+        });
+        const rangeStr = `R${args.startRow}C${args.startColumn}:R${args.endRow - 1}C${args.endColumn - 1}`;
+        const bordersSet = [];
+        if (args.top)
+            bordersSet.push("top");
+        if (args.bottom)
+            bordersSet.push("bottom");
+        if (args.left)
+            bordersSet.push("left");
+        if (args.right)
+            bordersSet.push("right");
+        if (args.innerHorizontal)
+            bordersSet.push("innerHorizontal");
+        if (args.innerVertical)
+            bordersSet.push("innerVertical");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully updated borders for range ${rangeStr}. Borders set: ${bordersSet.join(", ")}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error updating borders: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/gsheets_update_cell.js

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

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

@@ -0,0 +1,112 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_update_named_range",
+    description: "Update a named range's properties",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            namedRangeId: {
+                type: "string",
+                description: "The ID of the named range to update",
+            },
+            name: {
+                type: "string",
+                description: "New name for the range (optional)",
+            },
+            sheetId: {
+                type: "number",
+                description: "The ID of the sheet (optional)",
+            },
+            startRow: {
+                type: "number",
+                description: "Starting row index (0-based, optional)",
+            },
+            endRow: {
+                type: "number",
+                description: "Ending row index (exclusive, 0-based, optional)",
+            },
+            startColumn: {
+                type: "number",
+                description: "Starting column index (0-based, optional)",
+            },
+            endColumn: {
+                type: "number",
+                description: "Ending column index (exclusive, 0-based, optional)",
+            },
+        },
+        required: ["spreadsheetId", "namedRangeId"],
+    },
+};
+export async function updateNamedRange(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const namedRange = {
+            namedRangeId: args.namedRangeId,
+        };
+        const fields = [];
+        if (args.name !== undefined) {
+            namedRange.name = args.name;
+            fields.push("name");
+        }
+        if (args.sheetId !== undefined ||
+            args.startRow !== undefined ||
+            args.endRow !== undefined ||
+            args.startColumn !== undefined ||
+            args.endColumn !== undefined) {
+            namedRange.range = {};
+            if (args.sheetId !== undefined) {
+                namedRange.range.sheetId = args.sheetId;
+            }
+            if (args.startRow !== undefined) {
+                namedRange.range.startRowIndex = args.startRow;
+            }
+            if (args.endRow !== undefined) {
+                namedRange.range.endRowIndex = args.endRow;
+            }
+            if (args.startColumn !== undefined) {
+                namedRange.range.startColumnIndex = args.startColumn;
+            }
+            if (args.endColumn !== undefined) {
+                namedRange.range.endColumnIndex = args.endColumn;
+            }
+            fields.push("range");
+        }
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        updateNamedRange: {
+                            namedRange,
+                            fields: fields.join(","),
+                        },
+                    },
+                ],
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully updated named range ${args.namedRangeId}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error updating named range: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/gsheets_update_protected_range.js

@@ -0,0 +1,110 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_update_protected_range",
+    description: "Update protection settings for a protected range",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            protectedRangeId: {
+                type: "number",
+                description: "The ID of the protected range to update",
+            },
+            description: {
+                type: "string",
+                description: "New description for the protected range",
+            },
+            warningOnly: {
+                type: "boolean",
+                description: "If true, show a warning instead of preventing edits",
+            },
+            editors: {
+                type: "object",
+                properties: {
+                    users: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Email addresses of users who can edit",
+                    },
+                    groups: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Email addresses of groups who can edit",
+                    },
+                    domainUsersCanEdit: {
+                        type: "boolean",
+                        description: "Whether all users in the domain can edit",
+                    },
+                },
+                description: "Who can edit the protected range",
+            },
+        },
+        required: ["spreadsheetId", "protectedRangeId"],
+    },
+};
+export async function updateProtectedRange(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const protectedRange = {
+            protectedRangeId: args.protectedRangeId,
+        };
+        const fields = [];
+        if (args.description !== undefined) {
+            protectedRange.description = args.description;
+            fields.push("description");
+        }
+        if (args.warningOnly !== undefined) {
+            protectedRange.warningOnly = args.warningOnly;
+            fields.push("warningOnly");
+        }
+        if (args.editors) {
+            protectedRange.editors = {};
+            if (args.editors.users !== undefined) {
+                protectedRange.editors.users = args.editors.users;
+            }
+            if (args.editors.groups !== undefined) {
+                protectedRange.editors.groups = args.editors.groups;
+            }
+            if (args.editors.domainUsersCanEdit !== undefined) {
+                protectedRange.editors.domainUsersCanEdit = args.editors.domainUsersCanEdit;
+            }
+            fields.push("editors");
+        }
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        updateProtectedRange: {
+                            protectedRange,
+                            fields: fields.join(","),
+                        },
+                    },
+                ],
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully updated protected range ${args.protectedRangeId}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error updating protected range: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}