@alanse/mcp-server-google-workspace 0.2.0

package/dist/tools/sheets/protection/gsheets_add_conditional_format.js

@@ -0,0 +1,175 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_add_conditional_format",
+    description: "Add conditional formatting rules to cells",
+    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)",
+            },
+            rule: {
+                type: "object",
+                properties: {
+                    type: {
+                        type: "string",
+                        enum: ["NUMBER_GREATER", "NUMBER_LESS", "NUMBER_BETWEEN", "TEXT_CONTAINS", "TEXT_NOT_CONTAINS", "CUSTOM_FORMULA"],
+                        description: "The condition type",
+                    },
+                    value: {
+                        type: "string",
+                        description: "Value for comparison (for single value conditions)",
+                    },
+                    minValue: {
+                        type: "string",
+                        description: "Minimum value (for BETWEEN conditions)",
+                    },
+                    maxValue: {
+                        type: "string",
+                        description: "Maximum value (for BETWEEN conditions)",
+                    },
+                    formula: {
+                        type: "string",
+                        description: "Custom formula (for CUSTOM_FORMULA)",
+                    },
+                    backgroundColor: {
+                        type: "object",
+                        properties: {
+                            red: { type: "number", minimum: 0, maximum: 1 },
+                            green: { type: "number", minimum: 0, maximum: 1 },
+                            blue: { type: "number", minimum: 0, maximum: 1 },
+                        },
+                        description: "Background color to apply when condition is true",
+                    },
+                    textColor: {
+                        type: "object",
+                        properties: {
+                            red: { type: "number", minimum: 0, maximum: 1 },
+                            green: { type: "number", minimum: 0, maximum: 1 },
+                            blue: { type: "number", minimum: 0, maximum: 1 },
+                        },
+                        description: "Text color to apply when condition is true",
+                    },
+                    bold: {
+                        type: "boolean",
+                        description: "Make text bold when condition is true",
+                    },
+                    italic: {
+                        type: "boolean",
+                        description: "Make text italic when condition is true",
+                    },
+                },
+                required: ["type"],
+                description: "Conditional formatting rule",
+            },
+        },
+        required: ["spreadsheetId", "sheetId", "startRow", "endRow", "startColumn", "endColumn", "rule"],
+    },
+};
+export async function addConditionalFormat(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const booleanCondition = {
+            type: args.rule.type,
+        };
+        // Set condition values based on type
+        if (args.rule.type === "NUMBER_BETWEEN") {
+            booleanCondition.values = [
+                { userEnteredValue: args.rule.minValue },
+                { userEnteredValue: args.rule.maxValue },
+            ];
+        }
+        else if (args.rule.type === "CUSTOM_FORMULA") {
+            booleanCondition.values = [{ userEnteredValue: args.rule.formula }];
+        }
+        else if (args.rule.value) {
+            booleanCondition.values = [{ userEnteredValue: args.rule.value }];
+        }
+        // Build format to apply
+        const format = {};
+        if (args.rule.backgroundColor) {
+            format.backgroundColor = args.rule.backgroundColor;
+        }
+        if (args.rule.textColor || args.rule.bold || args.rule.italic) {
+            format.textFormat = {};
+            if (args.rule.textColor) {
+                format.textFormat.foregroundColor = args.rule.textColor;
+            }
+            if (args.rule.bold !== undefined) {
+                format.textFormat.bold = args.rule.bold;
+            }
+            if (args.rule.italic !== undefined) {
+                format.textFormat.italic = args.rule.italic;
+            }
+        }
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        addConditionalFormatRule: {
+                            rule: {
+                                ranges: [
+                                    {
+                                        sheetId: args.sheetId,
+                                        startRowIndex: args.startRow,
+                                        endRowIndex: args.endRow,
+                                        startColumnIndex: args.startColumn,
+                                        endColumnIndex: args.endColumn,
+                                    },
+                                ],
+                                booleanRule: {
+                                    condition: booleanCondition,
+                                    format,
+                                },
+                            },
+                            index: 0,
+                        },
+                    },
+                ],
+            },
+        });
+        const rangeStr = `R${args.startRow}C${args.startColumn}:R${args.endRow - 1}C${args.endColumn - 1}`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully added conditional formatting rule (${args.rule.type}) for range ${rangeStr}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error adding conditional format: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/sheets/protection/gsheets_add_named_range.js

@@ -0,0 +1,87 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_add_named_range",
+    description: "Create a named range in a spreadsheet",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            name: {
+                type: "string",
+                description: "The name for the range",
+            },
+            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", "name", "sheetId", "startRow", "endRow", "startColumn", "endColumn"],
+    },
+};
+export async function addNamedRange(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const response = await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        addNamedRange: {
+                            namedRange: {
+                                name: args.name,
+                                range: {
+                                    sheetId: args.sheetId,
+                                    startRowIndex: args.startRow,
+                                    endRowIndex: args.endRow,
+                                    startColumnIndex: args.startColumn,
+                                    endColumnIndex: args.endColumn,
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        const namedRangeId = response.data.replies?.[0]?.addNamedRange?.namedRange?.namedRangeId;
+        const rangeStr = `R${args.startRow}C${args.startColumn}:R${args.endRow - 1}C${args.endColumn - 1}`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully created named range "${args.name}" for ${rangeStr}. Named Range ID: ${namedRangeId}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error creating named range: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/sheets/protection/gsheets_add_protected_range.js

@@ -0,0 +1,127 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_add_protected_range",
+    description: "Add protection to a range to restrict editing",
+    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)",
+            },
+            description: {
+                type: "string",
+                description: "Description of the protected range (optional)",
+            },
+            warningOnly: {
+                type: "boolean",
+                description: "If true, show a warning instead of preventing edits (default: false)",
+            },
+            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", "sheetId", "startRow", "endRow", "startColumn", "endColumn"],
+    },
+};
+export async function addProtectedRange(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const protectedRange = {
+            range: {
+                sheetId: args.sheetId,
+                startRowIndex: args.startRow,
+                endRowIndex: args.endRow,
+                startColumnIndex: args.startColumn,
+                endColumnIndex: args.endColumn,
+            },
+            warningOnly: args.warningOnly || false,
+        };
+        if (args.description) {
+            protectedRange.description = args.description;
+        }
+        if (args.editors) {
+            protectedRange.editors = {};
+            if (args.editors.users && args.editors.users.length > 0) {
+                protectedRange.editors.users = args.editors.users;
+            }
+            if (args.editors.groups && args.editors.groups.length > 0) {
+                protectedRange.editors.groups = args.editors.groups;
+            }
+            if (args.editors.domainUsersCanEdit !== undefined) {
+                protectedRange.editors.domainUsersCanEdit = args.editors.domainUsersCanEdit;
+            }
+        }
+        const response = await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        addProtectedRange: {
+                            protectedRange,
+                        },
+                    },
+                ],
+            },
+        });
+        const addedProtection = response.data.replies?.[0]?.addProtectedRange?.protectedRange;
+        const rangeStr = `R${args.startRow}C${args.startColumn}:R${args.endRow - 1}C${args.endColumn - 1}`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully added protection to range ${rangeStr}. Protection ID: ${addedProtection?.protectedRangeId}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error adding protected range: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/sheets/protection/gsheets_delete_named_range.js

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

package/dist/tools/sheets/protection/gsheets_delete_protected_range.js

@@ -0,0 +1,56 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_delete_protected_range",
+    description: "Remove protection from 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 delete",
+            },
+        },
+        required: ["spreadsheetId", "protectedRangeId"],
+    },
+};
+export async function deleteProtectedRange(args) {
+    try {
+        const sheets = google.sheets("v4");
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        deleteProtectedRange: {
+                            protectedRangeId: args.protectedRangeId,
+                        },
+                    },
+                ],
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully deleted protected range ${args.protectedRangeId}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error deleting protected range: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/sheets/protection/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,
+        };
+    }
+}