@alanse/mcp-server-google-workspace 0.2.0

package/dist/tools/gsheets_create_filter.js

@@ -0,0 +1,81 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_create_filter",
+    description: "Create a basic filter for a range 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 createFilter(args) {
+    try {
+        const sheets = google.sheets("v4");
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        setBasicFilter: {
+                            filter: {
+                                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 created filter for range ${rangeStr}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error creating filter: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/gsheets_create_spreadsheet.js

@@ -0,0 +1,88 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_create_spreadsheet",
+    description: "Create a new Google Spreadsheet",
+    inputSchema: {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "The title of the new spreadsheet",
+            },
+            sheets: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        title: {
+                            type: "string",
+                            description: "Sheet title",
+                        },
+                        rowCount: {
+                            type: "number",
+                            description: "Number of rows (default: 1000)",
+                        },
+                        columnCount: {
+                            type: "number",
+                            description: "Number of columns (default: 26)",
+                        },
+                    },
+                    required: ["title"],
+                },
+                description: "Initial sheets to create (optional)",
+            },
+        },
+        required: ["title"],
+    },
+};
+export async function createSpreadsheet(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const requestBody = {
+            properties: {
+                title: args.title,
+            },
+        };
+        if (args.sheets && args.sheets.length > 0) {
+            requestBody.sheets = args.sheets.map((sheet) => ({
+                properties: {
+                    title: sheet.title,
+                    gridProperties: {
+                        rowCount: sheet.rowCount || 1000,
+                        columnCount: sheet.columnCount || 26,
+                    },
+                },
+            }));
+        }
+        const response = await sheets.spreadsheets.create({
+            requestBody,
+        });
+        const spreadsheetId = response.data.spreadsheetId;
+        const spreadsheetUrl = response.data.spreadsheetUrl;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        spreadsheetId,
+                        spreadsheetUrl,
+                        title: args.title,
+                        sheetsCount: response.data.sheets?.length || 0,
+                    }, null, 2),
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error creating spreadsheet: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/gsheets_delete_chart.js

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

package/dist/tools/gsheets_delete_columns.js

@@ -0,0 +1,69 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_delete_columns",
+    description: "Delete columns from 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) to delete",
+            },
+            count: {
+                type: "number",
+                description: "The number of columns to delete",
+            },
+        },
+        required: ["spreadsheetId", "sheetId", "startIndex", "count"],
+    },
+};
+export async function deleteColumns(args) {
+    try {
+        const sheets = google.sheets("v4");
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        deleteDimension: {
+                            range: {
+                                sheetId: args.sheetId,
+                                dimension: "COLUMNS",
+                                startIndex: args.startIndex,
+                                endIndex: args.startIndex + args.count,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully deleted ${args.count} column(s) starting at index ${args.startIndex}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error deleting columns: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

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

@@ -0,0 +1,69 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_delete_rows",
+    description: "Delete rows from 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) to delete",
+            },
+            count: {
+                type: "number",
+                description: "The number of rows to delete",
+            },
+        },
+        required: ["spreadsheetId", "sheetId", "startIndex", "count"],
+    },
+};
+export async function deleteRows(args) {
+    const sheets = google.sheets("v4");
+    try {
+        await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        deleteDimension: {
+                            range: {
+                                sheetId: args.sheetId,
+                                dimension: "ROWS",
+                                startIndex: args.startIndex,
+                                endIndex: args.startIndex + args.count,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully deleted ${args.count} row(s) starting at index ${args.startIndex}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error deleting rows: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/gsheets_delete_sheet.js

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

package/dist/tools/gsheets_duplicate_sheet.js

@@ -0,0 +1,72 @@
+import { google } from "googleapis";
+export const schema = {
+    name: "gsheets_duplicate_sheet",
+    description: "Duplicate a sheet within the same spreadsheet",
+    inputSchema: {
+        type: "object",
+        properties: {
+            spreadsheetId: {
+                type: "string",
+                description: "The ID of the spreadsheet",
+            },
+            sourceSheetId: {
+                type: "number",
+                description: "The ID of the sheet to duplicate",
+            },
+            newSheetName: {
+                type: "string",
+                description: "The name for the duplicated sheet (optional)",
+            },
+            insertSheetIndex: {
+                type: "number",
+                description: "The index where the new sheet should be inserted (optional)",
+            },
+        },
+        required: ["spreadsheetId", "sourceSheetId"],
+    },
+};
+export async function duplicateSheet(args) {
+    try {
+        const sheets = google.sheets("v4");
+        const duplicateRequest = {
+            sourceSheetId: args.sourceSheetId,
+        };
+        if (args.insertSheetIndex !== undefined) {
+            duplicateRequest.insertSheetIndex = args.insertSheetIndex;
+        }
+        if (args.newSheetName !== undefined) {
+            duplicateRequest.newSheetName = args.newSheetName;
+        }
+        const response = await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: args.spreadsheetId,
+            requestBody: {
+                requests: [
+                    {
+                        duplicateSheet: duplicateRequest,
+                    },
+                ],
+            },
+        });
+        const duplicatedSheet = response.data.replies?.[0]?.duplicateSheet?.properties;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully duplicated sheet. New sheet ID: ${duplicatedSheet?.sheetId}, Title: ${duplicatedSheet?.title}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error duplicating sheet: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}