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

package/dist/tools/basic/gsheets_create_spreadsheet.js

@@ -1,88 +0,0 @@
-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/basic/gsheets_delete_columns.js

@@ -1,69 +0,0 @@
-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/basic/gsheets_delete_rows.js

@@ -1,69 +0,0 @@
-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/basic/gsheets_delete_sheet.js

@@ -1,56 +0,0 @@
-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/basic/gsheets_duplicate_sheet.js

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

package/dist/tools/basic/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/basic/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/basic/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,
-        };
-    }
-}

package/dist/tools/basic/gsheets_read.js

@@ -1,120 +0,0 @@
-import { google } from "googleapis";
-export const schema = {
-    name: "gsheets_read",
-    description: "Read data from a Google Spreadsheet with flexible options for ranges and formatting",
-    inputSchema: {
-        type: "object",
-        properties: {
-            spreadsheetId: {
-                type: "string",
-                description: "The ID of the spreadsheet to read",
-            },
-            ranges: {
-                type: "array",
-                items: {
-                    type: "string",
-                },
-                description: "Optional array of A1 notation ranges like ['Sheet1!A1:B10']. If not provided, reads entire sheet.",
-            },
-            sheetId: {
-                type: "number",
-                description: "Optional specific sheet ID to read. If not provided with ranges, reads first sheet.",
-            },
-        },
-        required: ["spreadsheetId"],
-    },
-};
-const sheets = google.sheets("v4");
-function getA1Notation(row, col) {
-    let a1 = "";
-    while (col > 0) {
-        col--;
-        a1 = String.fromCharCode(65 + (col % 26)) + a1;
-        col = Math.floor(col / 26);
-    }
-    return `${a1}${row + 1}`;
-}
-async function processSheetData(response) {
-    const results = [];
-    // Handle both single and multiple ranges
-    const valueRanges = response.data.valueRanges || [response.data];
-    for (const range of valueRanges) {
-        const values = range.values || [];
-        if (values.length === 0)
-            continue;
-        // Extract sheet name from range
-        const rangeParts = range.range?.split("!") || [];
-        const sheetName = rangeParts[0]?.replace(/'/g, "") || "Sheet1";
-        // Process data with cell locations
-        const processedValues = values.map((row, rowIndex) => row.map((cell, colIndex) => ({
-            value: cell,
-            location: `${sheetName}!${getA1Notation(rowIndex, colIndex + 1)}`,
-        })));
-        // Process headers with locations
-        const columnHeaders = processedValues[0];
-        const data = processedValues.slice(1);
-        results.push({
-            sheetName,
-            data,
-            totalRows: values.length,
-            totalColumns: columnHeaders.length,
-            columnHeaders,
-        });
-    }
-    return results;
-}
-export async function readSheet(args) {
-    try {
-        let response;
-        if (args.ranges) {
-            // Read specific ranges
-            response = await sheets.spreadsheets.values.batchGet({
-                spreadsheetId: args.spreadsheetId,
-                ranges: args.ranges,
-            });
-        }
-        else if (args.sheetId !== undefined) {
-            // Get sheet name from sheet ID first
-            const metadata = await sheets.spreadsheets.get({
-                spreadsheetId: args.spreadsheetId,
-                fields: "sheets.properties",
-            });
-            const sheet = metadata.data.sheets?.find((s) => s.properties?.sheetId === args.sheetId);
-            if (!sheet?.properties?.title) {
-                throw new Error(`Sheet ID ${args.sheetId} not found`);
-            }
-            response = await sheets.spreadsheets.values.get({
-                spreadsheetId: args.spreadsheetId,
-                range: sheet.properties.title,
-            });
-        }
-        else {
-            // Read first sheet by default
-            response = await sheets.spreadsheets.values.get({
-                spreadsheetId: args.spreadsheetId,
-                range: "A:ZZ", // Read all possible columns
-            });
-        }
-        const processedData = await processSheetData(response);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(processedData, null, 2),
-                },
-            ],
-            isError: false,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error reading spreadsheet: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}