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

package/dist/tools/gsheets_find_replace.js

@@ -1,124 +0,0 @@
-import { google } from "googleapis";
-export const schema = {
-    name: "gsheets_find_replace",
-    description: "Find and replace text in a range or entire sheet",
-    inputSchema: {
-        type: "object",
-        properties: {
-            spreadsheetId: {
-                type: "string",
-                description: "The ID of the spreadsheet",
-            },
-            sheetId: {
-                type: "number",
-                description: "The ID of the sheet (optional, searches all sheets if omitted)",
-            },
-            find: {
-                type: "string",
-                description: "Text to find",
-            },
-            replacement: {
-                type: "string",
-                description: "Replacement text",
-            },
-            matchCase: {
-                type: "boolean",
-                description: "Case-sensitive matching (default: false)",
-            },
-            matchEntireCell: {
-                type: "boolean",
-                description: "Match entire cell content (default: false)",
-            },
-            searchByRegex: {
-                type: "boolean",
-                description: "Use regex pattern (default: false)",
-            },
-            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", "find", "replacement"],
-    },
-};
-export async function findReplace(args) {
-    try {
-        const sheets = google.sheets("v4");
-        const findReplaceSpec = {
-            find: args.find,
-            replacement: args.replacement,
-            matchCase: args.matchCase || false,
-            matchEntireCell: args.matchEntireCell || false,
-            searchByRegex: args.searchByRegex || false,
-        };
-        // Add range if specified
-        if (args.sheetId !== undefined ||
-            args.startRow !== undefined ||
-            args.endRow !== undefined ||
-            args.startColumn !== undefined ||
-            args.endColumn !== undefined) {
-            findReplaceSpec.range = {};
-            if (args.sheetId !== undefined) {
-                findReplaceSpec.range.sheetId = args.sheetId;
-            }
-            if (args.startRow !== undefined) {
-                findReplaceSpec.range.startRowIndex = args.startRow;
-            }
-            if (args.endRow !== undefined) {
-                findReplaceSpec.range.endRowIndex = args.endRow;
-            }
-            if (args.startColumn !== undefined) {
-                findReplaceSpec.range.startColumnIndex = args.startColumn;
-            }
-            if (args.endColumn !== undefined) {
-                findReplaceSpec.range.endColumnIndex = args.endColumn;
-            }
-        }
-        const response = await sheets.spreadsheets.batchUpdate({
-            spreadsheetId: args.spreadsheetId,
-            requestBody: {
-                requests: [
-                    {
-                        findReplace: findReplaceSpec,
-                    },
-                ],
-            },
-        });
-        const occurrencesChanged = response.data.replies?.[0]?.findReplace?.occurrencesChanged || 0;
-        const rowsChanged = response.data.replies?.[0]?.findReplace?.rowsChanged || 0;
-        const sheetsChanged = response.data.replies?.[0]?.findReplace?.sheetsChanged || 0;
-        const valuesChanged = response.data.replies?.[0]?.findReplace?.valuesChanged || 0;
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Successfully replaced "${args.find}" with "${args.replacement}". Changed: ${occurrencesChanged} occurrences, ${rowsChanged} rows, ${sheetsChanged} sheets, ${valuesChanged} values.`,
-                },
-            ],
-            isError: false,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error finding and replacing: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}

package/dist/tools/gsheets_format_cells.js

@@ -1,161 +0,0 @@
-import { google } from "googleapis";
-export const schema = {
-    name: "gsheets_format_cells",
-    description: "Format cells in a Google Spreadsheet (font, colors, alignment, 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)",
-            },
-            format: {
-                type: "object",
-                properties: {
-                    bold: { type: "boolean", description: "Make text bold" },
-                    italic: { type: "boolean", description: "Make text italic" },
-                    fontSize: { type: "number", description: "Font size in points" },
-                    fontFamily: { type: "string", description: "Font family name" },
-                    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 (RGB values 0-1)",
-                    },
-                    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 (RGB values 0-1)",
-                    },
-                    horizontalAlignment: {
-                        type: "string",
-                        enum: ["LEFT", "CENTER", "RIGHT"],
-                        description: "Horizontal text alignment",
-                    },
-                    verticalAlignment: {
-                        type: "string",
-                        enum: ["TOP", "MIDDLE", "BOTTOM"],
-                        description: "Vertical text alignment",
-                    },
-                },
-                description: "Format options to apply",
-            },
-        },
-        required: ["spreadsheetId", "sheetId", "startRow", "endRow", "startColumn", "endColumn", "format"],
-    },
-};
-export async function formatCells(args) {
-    try {
-        const sheets = google.sheets("v4");
-        const cellFormat = {};
-        const fields = [];
-        if (args.format.bold !== undefined || args.format.italic !== undefined ||
-            args.format.fontSize !== undefined || args.format.fontFamily !== undefined ||
-            args.format.textColor !== undefined) {
-            cellFormat.textFormat = {};
-            if (args.format.bold !== undefined) {
-                cellFormat.textFormat.bold = args.format.bold;
-                fields.push("userEnteredFormat.textFormat.bold");
-            }
-            if (args.format.italic !== undefined) {
-                cellFormat.textFormat.italic = args.format.italic;
-                fields.push("userEnteredFormat.textFormat.italic");
-            }
-            if (args.format.fontSize !== undefined) {
-                cellFormat.textFormat.fontSize = args.format.fontSize;
-                fields.push("userEnteredFormat.textFormat.fontSize");
-            }
-            if (args.format.fontFamily !== undefined) {
-                cellFormat.textFormat.fontFamily = args.format.fontFamily;
-                fields.push("userEnteredFormat.textFormat.fontFamily");
-            }
-            if (args.format.textColor !== undefined) {
-                cellFormat.textFormat.foregroundColor = args.format.textColor;
-                fields.push("userEnteredFormat.textFormat.foregroundColor");
-            }
-        }
-        if (args.format.backgroundColor !== undefined) {
-            cellFormat.backgroundColor = args.format.backgroundColor;
-            fields.push("userEnteredFormat.backgroundColor");
-        }
-        if (args.format.horizontalAlignment !== undefined) {
-            cellFormat.horizontalAlignment = args.format.horizontalAlignment;
-            fields.push("userEnteredFormat.horizontalAlignment");
-        }
-        if (args.format.verticalAlignment !== undefined) {
-            cellFormat.verticalAlignment = args.format.verticalAlignment;
-            fields.push("userEnteredFormat.verticalAlignment");
-        }
-        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: cellFormat,
-                            },
-                            fields: fields.join(","),
-                        },
-                    },
-                ],
-            },
-        });
-        const rangeStr = `R${args.startRow}C${args.startColumn}:R${args.endRow - 1}C${args.endColumn - 1}`;
-        const appliedFormats = Object.keys(args.format).join(", ");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Successfully formatted cells in range ${rangeStr}. Applied formats: ${appliedFormats}`,
-                },
-            ],
-            isError: false,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error formatting cells: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}

package/dist/tools/gsheets_freeze_columns.js

@@ -1,67 +0,0 @@
-import { google } from "googleapis";
-export const schema = {
-    name: "gsheets_freeze_columns",
-    description: "Freeze columns at the left of a sheet",
-    inputSchema: {
-        type: "object",
-        properties: {
-            spreadsheetId: {
-                type: "string",
-                description: "The ID of the spreadsheet",
-            },
-            sheetId: {
-                type: "number",
-                description: "The ID of the sheet",
-            },
-            count: {
-                type: "number",
-                description: "Number of columns to freeze (0 to unfreeze all)",
-            },
-        },
-        required: ["spreadsheetId", "sheetId", "count"],
-    },
-};
-export async function freezeColumns(args) {
-    try {
-        const sheets = google.sheets("v4");
-        await sheets.spreadsheets.batchUpdate({
-            spreadsheetId: args.spreadsheetId,
-            requestBody: {
-                requests: [
-                    {
-                        updateSheetProperties: {
-                            properties: {
-                                sheetId: args.sheetId,
-                                gridProperties: {
-                                    frozenColumnCount: args.count,
-                                },
-                            },
-                            fields: "gridProperties.frozenColumnCount",
-                        },
-                    },
-                ],
-            },
-        });
-        const action = args.count === 0 ? "Unfroze all columns" : `Froze ${args.count} column(s)`;
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `${action} on sheet ${args.sheetId}`,
-                },
-            ],
-            isError: false,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error freezing columns: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}

package/dist/tools/gsheets_freeze_rows.js

@@ -1,67 +0,0 @@
-import { google } from "googleapis";
-export const schema = {
-    name: "gsheets_freeze_rows",
-    description: "Freeze rows at the top of a sheet",
-    inputSchema: {
-        type: "object",
-        properties: {
-            spreadsheetId: {
-                type: "string",
-                description: "The ID of the spreadsheet",
-            },
-            sheetId: {
-                type: "number",
-                description: "The ID of the sheet",
-            },
-            count: {
-                type: "number",
-                description: "Number of rows to freeze (0 to unfreeze all)",
-            },
-        },
-        required: ["spreadsheetId", "sheetId", "count"],
-    },
-};
-export async function freezeRows(args) {
-    try {
-        const sheets = google.sheets("v4");
-        await sheets.spreadsheets.batchUpdate({
-            spreadsheetId: args.spreadsheetId,
-            requestBody: {
-                requests: [
-                    {
-                        updateSheetProperties: {
-                            properties: {
-                                sheetId: args.sheetId,
-                                gridProperties: {
-                                    frozenRowCount: args.count,
-                                },
-                            },
-                            fields: "gridProperties.frozenRowCount",
-                        },
-                    },
-                ],
-            },
-        });
-        const action = args.count === 0 ? "Unfroze all rows" : `Froze ${args.count} row(s)`;
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `${action} on sheet ${args.sheetId}`,
-                },
-            ],
-            isError: false,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error freezing rows: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}

package/dist/tools/gsheets_insert_columns.js

@@ -1,69 +0,0 @@
-import { google } from "googleapis";
-export const schema = {
-    name: "gsheets_insert_columns",
-    description: "Insert empty columns into 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",
-            },
-            startIndex: {
-                type: "number",
-                description: "The starting column index (0-based) where columns will be inserted",
-            },
-            count: {
-                type: "number",
-                description: "The number of columns to insert",
-            },
-        },
-        required: ["spreadsheetId", "sheetId", "startIndex", "count"],
-    },
-};
-export async function insertColumns(args) {
-    const sheets = google.sheets("v4");
-    try {
-        await sheets.spreadsheets.batchUpdate({
-            spreadsheetId: args.spreadsheetId,
-            requestBody: {
-                requests: [
-                    {
-                        insertDimension: {
-                            range: {
-                                sheetId: args.sheetId,
-                                dimension: "COLUMNS",
-                                startIndex: args.startIndex,
-                                endIndex: args.startIndex + args.count,
-                            },
-                        },
-                    },
-                ],
-            },
-        });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Successfully inserted ${args.count} column(s) starting at index ${args.startIndex}`,
-                },
-            ],
-            isError: false,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error inserting columns: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}

package/dist/tools/gsheets_insert_rows.js

@@ -1,69 +0,0 @@
-import { google } from "googleapis";
-export const schema = {
-    name: "gsheets_insert_rows",
-    description: "Insert empty rows into 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",
-            },
-            startIndex: {
-                type: "number",
-                description: "The starting row index (0-based) where rows will be inserted",
-            },
-            count: {
-                type: "number",
-                description: "The number of rows to insert",
-            },
-        },
-        required: ["spreadsheetId", "sheetId", "startIndex", "count"],
-    },
-};
-export async function insertRows(args) {
-    const sheets = google.sheets("v4");
-    try {
-        await sheets.spreadsheets.batchUpdate({
-            spreadsheetId: args.spreadsheetId,
-            requestBody: {
-                requests: [
-                    {
-                        insertDimension: {
-                            range: {
-                                sheetId: args.sheetId,
-                                dimension: "ROWS",
-                                startIndex: args.startIndex,
-                                endIndex: args.startIndex + args.count,
-                            },
-                        },
-                    },
-                ],
-            },
-        });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Successfully inserted ${args.count} row(s) starting at index ${args.startIndex}`,
-                },
-            ],
-            isError: false,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error inserting rows: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}

package/dist/tools/gsheets_list_sheets.js

@@ -1,53 +0,0 @@
-import { google } from "googleapis";
-export const schema = {
-    name: "gsheets_list_sheets",
-    description: "List all sheets (tabs) within a Google Spreadsheet",
-    inputSchema: {
-        type: "object",
-        properties: {
-            spreadsheetId: {
-                type: "string",
-                description: "The ID of the spreadsheet",
-            },
-        },
-        required: ["spreadsheetId"],
-    },
-};
-export async function listSheets(args) {
-    try {
-        const sheets = google.sheets("v4");
-        const response = await sheets.spreadsheets.get({
-            spreadsheetId: args.spreadsheetId,
-            fields: "sheets.properties",
-        });
-        const sheetsList = response.data.sheets?.map((sheet) => ({
-            sheetId: sheet.properties?.sheetId,
-            title: sheet.properties?.title,
-            index: sheet.properties?.index,
-            gridProperties: {
-                rowCount: sheet.properties?.gridProperties?.rowCount,
-                columnCount: sheet.properties?.gridProperties?.columnCount,
-            },
-        })) || [];
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({ sheets: sheetsList }, null, 2),
-                },
-            ],
-            isError: false,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error listing sheets: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}