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

package/dist/tools/gsheets_unmerge_cells.js

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

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

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

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

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

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