@triffon/google-docs-mcp 1.11.3-triffon

package/dist/tools/sheets/listTables.js

@@ -0,0 +1,55 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSheetsClient } from '../../clients.js';
+import * as SheetsHelpers from '../../googleSheetsApiHelpers.js';
+export function register(server) {
+    server.addTool({
+        name: 'listTables',
+        description: 'Lists all tables in a spreadsheet or specific sheet. Use this to discover table names and IDs before performing table operations.',
+        parameters: z.strictObject({
+            spreadsheetId: z
+                .string()
+                .describe('The spreadsheet ID — the long string between /d/ and /edit in a Google Sheets URL.'),
+            sheetName: z
+                .string()
+                .optional()
+                .describe('Optional: filter tables to only those on this specific sheet.'),
+        }),
+        execute: async (args, { log }) => {
+            const sheets = await getSheetsClient();
+            log.info(`Listing tables for spreadsheet: ${args.spreadsheetId}`);
+            try {
+                const tables = await SheetsHelpers.listAllTables(sheets, args.spreadsheetId, args.sheetName);
+                if (tables.length === 0) {
+                    return JSON.stringify({
+                        spreadsheetId: args.spreadsheetId,
+                        sheetFilter: args.sheetName || 'All sheets',
+                        tables: [],
+                        message: 'No tables found. Use createTable to create a table.',
+                    }, null, 2);
+                }
+                const tableList = tables.map((item) => ({
+                    tableId: item.table.tableId,
+                    name: item.table.name,
+                    sheetName: item.sheetName,
+                    columnCount: item.table.columnProperties?.length || 0,
+                    range: item.table.range
+                        ? `${item.sheetName}!${SheetsHelpers.rowColToA1(item.table.range.startRowIndex || 0, item.table.range.startColumnIndex || 0)}:${SheetsHelpers.rowColToA1((item.table.range.endRowIndex || 1) - 1, (item.table.range.endColumnIndex || 1) - 1)}`
+                        : 'Unknown',
+                }));
+                return JSON.stringify({
+                    spreadsheetId: args.spreadsheetId,
+                    sheetFilter: args.sheetName || 'All sheets',
+                    count: tableList.length,
+                    tables: tableList,
+                }, null, 2);
+            }
+            catch (error) {
+                log.error(`Error listing tables: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to list tables: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/sheets/protectRange.js

@@ -0,0 +1,59 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSheetsClient } from '../../clients.js';
+import * as SheetsHelpers from '../../googleSheetsApiHelpers.js';
+export function register(server) {
+    server.addTool({
+        name: 'protectRange',
+        description: "Locks (protects) a range or an entire sheet to prevent accidental edits. Optionally specify a description. The protection applies to the authenticated user's account.",
+        parameters: z.strictObject({
+            spreadsheetId: z
+                .string()
+                .describe('The spreadsheet ID — the long string between /d/ and /edit in a Google Sheets URL.'),
+            sheetName: z
+                .string()
+                .optional()
+                .describe('Name of the sheet/tab. Defaults to the first sheet if not provided.'),
+            range: z
+                .string()
+                .optional()
+                .describe('A1 notation range to protect (e.g., "A1:D10", "1:1"). Omit to protect the entire sheet.'),
+            description: z
+                .string()
+                .optional()
+                .describe('Human-readable description for this protection (e.g., "Header row — do not edit").'),
+            warningOnly: z
+                .boolean()
+                .optional()
+                .describe('If true, shows a warning when editing but does not block it. Defaults to false (fully locked).'),
+        }),
+        execute: async (args, { log }) => {
+            const sheets = await getSheetsClient();
+            log.info(`Protecting range in spreadsheet ${args.spreadsheetId}`);
+            try {
+                const sheetId = await SheetsHelpers.resolveSheetId(sheets, args.spreadsheetId, args.sheetName);
+                const protectedRange = {
+                    description: args.description ?? '',
+                    warningOnly: args.warningOnly ?? false,
+                    range: args.range ? SheetsHelpers.parseA1ToGridRange(args.range, sheetId) : { sheetId },
+                };
+                const response = await sheets.spreadsheets.batchUpdate({
+                    spreadsheetId: args.spreadsheetId,
+                    requestBody: {
+                        requests: [{ addProtectedRange: { protectedRange } }],
+                    },
+                });
+                const result = response.data.replies?.[0]?.addProtectedRange?.protectedRange;
+                const target = args.range ? `range "${args.range}"` : 'entire sheet';
+                const mode = args.warningOnly ? 'warning-only' : 'fully locked';
+                return `Successfully protected ${target} (Protection ID: ${result?.protectedRangeId}, mode: ${mode}).`;
+            }
+            catch (error) {
+                log.error(`Error protecting range: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to protect range: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/sheets/readCellFormat.js

@@ -0,0 +1,143 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSheetsClient } from '../../clients.js';
+import { rowColToA1 } from '../../googleSheetsApiHelpers.js';
+/**
+ * Converts a Google Sheets RGBA color object (0-1 range) to a hex string.
+ * Returns null if the color is undefined or has no meaningful channels.
+ */
+function rgbaToHex(color) {
+    if (!color)
+        return null;
+    const r = Math.round((color.red ?? 0) * 255);
+    const g = Math.round((color.green ?? 0) * 255);
+    const b = Math.round((color.blue ?? 0) * 255);
+    return `#${r.toString(16).padStart(2, '0').toUpperCase()}${g.toString(16).padStart(2, '0').toUpperCase()}${b.toString(16).padStart(2, '0').toUpperCase()}`;
+}
+/**
+ * Extracts a simplified formatting summary from a Google Sheets CellFormat object.
+ * Only includes properties that are explicitly set (non-default).
+ */
+function simplifyFormat(fmt) {
+    if (!fmt)
+        return null;
+    const result = {};
+    // Text formatting
+    if (fmt.textFormat) {
+        const tf = {};
+        if (fmt.textFormat.bold)
+            tf.bold = true;
+        if (fmt.textFormat.italic)
+            tf.italic = true;
+        if (fmt.textFormat.strikethrough)
+            tf.strikethrough = true;
+        if (fmt.textFormat.underline)
+            tf.underline = true;
+        if (fmt.textFormat.fontSize != null)
+            tf.fontSize = fmt.textFormat.fontSize;
+        if (fmt.textFormat.fontFamily)
+            tf.fontFamily = fmt.textFormat.fontFamily;
+        if (fmt.textFormat.foregroundColorStyle?.rgbColor) {
+            tf.foregroundColor = rgbaToHex(fmt.textFormat.foregroundColorStyle.rgbColor);
+        }
+        else if (fmt.textFormat.foregroundColor) {
+            tf.foregroundColor = rgbaToHex(fmt.textFormat.foregroundColor);
+        }
+        if (Object.keys(tf).length > 0)
+            result.textFormat = tf;
+    }
+    // Background color
+    if (fmt.backgroundColorStyle?.rgbColor) {
+        result.backgroundColor = rgbaToHex(fmt.backgroundColorStyle.rgbColor);
+    }
+    else if (fmt.backgroundColor) {
+        result.backgroundColor = rgbaToHex(fmt.backgroundColor);
+    }
+    // Alignment
+    if (fmt.horizontalAlignment)
+        result.horizontalAlignment = fmt.horizontalAlignment;
+    if (fmt.verticalAlignment)
+        result.verticalAlignment = fmt.verticalAlignment;
+    // Number format
+    if (fmt.numberFormat) {
+        result.numberFormat = {
+            type: fmt.numberFormat.type,
+            pattern: fmt.numberFormat.pattern,
+        };
+    }
+    // Borders
+    if (fmt.borders) {
+        const borders = {};
+        for (const side of ['top', 'bottom', 'left', 'right']) {
+            if (fmt.borders[side]) {
+                borders[side] = {
+                    style: fmt.borders[side].style,
+                    ...(fmt.borders[side].colorStyle?.rgbColor
+                        ? { color: rgbaToHex(fmt.borders[side].colorStyle.rgbColor) }
+                        : fmt.borders[side].color
+                            ? { color: rgbaToHex(fmt.borders[side].color) }
+                            : {}),
+                };
+            }
+        }
+        if (Object.keys(borders).length > 0)
+            result.borders = borders;
+    }
+    // Wrap strategy
+    if (fmt.wrapStrategy)
+        result.wrapStrategy = fmt.wrapStrategy;
+    return Object.keys(result).length > 0 ? result : null;
+}
+export function register(server) {
+    server.addTool({
+        name: 'readCellFormat',
+        description: 'Reads the formatting/style of cells in a given range. Returns formatting details like bold, italic, fontSize, fontFamily, colors, alignment, borders, and number format per cell.',
+        parameters: z.strictObject({
+            spreadsheetId: z
+                .string()
+                .describe('The spreadsheet ID — the long string between /d/ and /edit in a Google Sheets URL.'),
+            range: z
+                .string()
+                .describe('A1 notation range to read formatting from (e.g., "Sheet1!A1:D5" or "A1:B2").'),
+        }),
+        execute: async (args, { log }) => {
+            const sheets = await getSheetsClient();
+            log.info(`Reading cell format for range "${args.range}" in spreadsheet ${args.spreadsheetId}`);
+            try {
+                const response = await sheets.spreadsheets.get({
+                    spreadsheetId: args.spreadsheetId,
+                    ranges: [args.range],
+                    includeGridData: true,
+                    fields: 'sheets.data.rowData.values.userEnteredFormat,sheets.data.startRow,sheets.data.startColumn',
+                });
+                const sheetData = response.data.sheets?.[0]?.data?.[0];
+                if (!sheetData?.rowData) {
+                    return JSON.stringify({ range: args.range, cells: [] }, null, 2);
+                }
+                const startRow = sheetData.startRow ?? 0;
+                const startCol = sheetData.startColumn ?? 0;
+                const cells = [];
+                for (let rowIdx = 0; rowIdx < sheetData.rowData.length; rowIdx++) {
+                    const row = sheetData.rowData[rowIdx];
+                    if (!row.values)
+                        continue;
+                    for (let colIdx = 0; colIdx < row.values.length; colIdx++) {
+                        const cellData = row.values[colIdx];
+                        const fmt = simplifyFormat(cellData?.userEnteredFormat);
+                        if (fmt) {
+                            const cellRef = rowColToA1(startRow + rowIdx, startCol + colIdx);
+                            cells.push({ cell: cellRef, format: fmt });
+                        }
+                    }
+                }
+                return JSON.stringify({ range: args.range, cells }, null, 2);
+            }
+            catch (error) {
+                log.error(`Error reading cell format for spreadsheet ${args.spreadsheetId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to read cell format: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/sheets/readSpreadsheet.js

@@ -0,0 +1,36 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSheetsClient } from '../../clients.js';
+import * as SheetsHelpers from '../../googleSheetsApiHelpers.js';
+export function register(server) {
+    server.addTool({
+        name: 'readSpreadsheet',
+        description: 'Reads data from a range in a spreadsheet. Returns rows as arrays. Use A1 notation for the range (e.g., "Sheet1!A1:C10").',
+        parameters: z.strictObject({
+            spreadsheetId: z
+                .string()
+                .describe('The spreadsheet ID — the long string between /d/ and /edit in a Google Sheets URL.'),
+            range: z.string().describe('A1 notation range to read (e.g., "A1:B10" or "Sheet1!A1:B10").'),
+            valueRenderOption: z
+                .enum(['FORMATTED_VALUE', 'UNFORMATTED_VALUE', 'FORMULA'])
+                .optional()
+                .default('FORMATTED_VALUE')
+                .describe('How values should be rendered in the output.'),
+        }),
+        execute: async (args, { log }) => {
+            const sheets = await getSheetsClient();
+            log.info(`Reading spreadsheet ${args.spreadsheetId}, range: ${args.range}`);
+            try {
+                const response = await SheetsHelpers.readRange(sheets, args.spreadsheetId, args.range, args.valueRenderOption);
+                const values = response.values || [];
+                return JSON.stringify({ range: args.range, values }, null, 2);
+            }
+            catch (error) {
+                log.error(`Error reading spreadsheet ${args.spreadsheetId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to read spreadsheet: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/sheets/renameSheet.js

@@ -0,0 +1,48 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSheetsClient } from '../../clients.js';
+export function register(server) {
+    server.addTool({
+        name: 'renameSheet',
+        description: 'Renames a sheet (tab) in a spreadsheet. Use getSpreadsheetInfo to find the numeric sheet ID.',
+        parameters: z.strictObject({
+            spreadsheetId: z
+                .string()
+                .describe('The spreadsheet ID — the long string between /d/ and /edit in a Google Sheets URL.'),
+            sheetId: z
+                .number()
+                .int()
+                .describe('The numeric sheet ID to rename. Use getSpreadsheetInfo to find sheet IDs.'),
+            newName: z.string().min(1).describe('The new name for the sheet.'),
+        }),
+        execute: async (args, { log }) => {
+            const sheets = await getSheetsClient();
+            log.info(`Renaming sheet ID ${args.sheetId} to "${args.newName}" in spreadsheet ${args.spreadsheetId}`);
+            try {
+                await sheets.spreadsheets.batchUpdate({
+                    spreadsheetId: args.spreadsheetId,
+                    requestBody: {
+                        requests: [
+                            {
+                                updateSheetProperties: {
+                                    properties: {
+                                        sheetId: args.sheetId,
+                                        title: args.newName,
+                                    },
+                                    fields: 'title',
+                                },
+                            },
+                        ],
+                    },
+                });
+                return `Successfully renamed sheet (ID: ${args.sheetId}) to "${args.newName}".`;
+            }
+            catch (error) {
+                log.error(`Error renaming sheet in spreadsheet ${args.spreadsheetId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to rename sheet: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/sheets/setCellBorders.js

@@ -0,0 +1,94 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSheetsClient } from '../../clients.js';
+import * as SheetsHelpers from '../../googleSheetsApiHelpers.js';
+const borderStyleEnum = z.enum([
+    'SOLID',
+    'SOLID_MEDIUM',
+    'SOLID_THICK',
+    'DOTTED',
+    'DASHED',
+    'DOUBLE',
+    'NONE',
+]);
+const createBorderSchema = () => z
+    .object({
+    style: borderStyleEnum.describe('Border line style.'),
+    color: z
+        .string()
+        .optional()
+        .describe('Border color as hex (e.g., "#000000"). Defaults to black.'),
+})
+    .optional();
+export function register(server) {
+    server.addTool({
+        name: 'setCellBorders',
+        description: 'Sets borders on a range of cells. Each side (top, bottom, left, right, innerHorizontal, innerVertical) can be configured independently with a style and color. Use style "NONE" to remove a border.',
+        parameters: z
+            .object({
+            spreadsheetId: z
+                .string()
+                .describe('The spreadsheet ID — the long string between /d/ and /edit in a Google Sheets URL.'),
+            range: z.string().describe('A1 notation range (e.g., "Sheet1!A1:D10", "1:1", "A:A").'),
+            top: createBorderSchema().describe('Top border of the range.'),
+            bottom: createBorderSchema().describe('Bottom border of the range.'),
+            left: createBorderSchema().describe('Left border of the range.'),
+            right: createBorderSchema().describe('Right border of the range.'),
+            innerHorizontal: createBorderSchema().describe('Horizontal borders between rows inside the range.'),
+            innerVertical: createBorderSchema().describe('Vertical borders between columns inside the range.'),
+        })
+            .refine((d) => d.top !== undefined ||
+            d.bottom !== undefined ||
+            d.left !== undefined ||
+            d.right !== undefined ||
+            d.innerHorizontal !== undefined ||
+            d.innerVertical !== undefined, { message: 'At least one border side must be specified.' }),
+        execute: async (args, { log }) => {
+            const sheets = await getSheetsClient();
+            log.info(`Setting borders on range "${args.range}" in spreadsheet ${args.spreadsheetId}`);
+            try {
+                const { sheetName, a1Range } = SheetsHelpers.parseRange(args.range);
+                const sheetId = await SheetsHelpers.resolveSheetId(sheets, args.spreadsheetId, sheetName);
+                const gridRange = SheetsHelpers.parseA1ToGridRange(a1Range, sheetId);
+                const buildBorder = (b) => {
+                    if (!b)
+                        return undefined;
+                    const border = { style: b.style };
+                    if (b.color) {
+                        const rgb = SheetsHelpers.hexToRgb(b.color);
+                        if (!rgb)
+                            throw new UserError(`Invalid border color: "${b.color}".`);
+                        border.colorStyle = { rgbColor: rgb };
+                    }
+                    return border;
+                };
+                const borders = {};
+                if (args.top !== undefined)
+                    borders.top = buildBorder(args.top);
+                if (args.bottom !== undefined)
+                    borders.bottom = buildBorder(args.bottom);
+                if (args.left !== undefined)
+                    borders.left = buildBorder(args.left);
+                if (args.right !== undefined)
+                    borders.right = buildBorder(args.right);
+                if (args.innerHorizontal !== undefined)
+                    borders.innerHorizontal = buildBorder(args.innerHorizontal);
+                if (args.innerVertical !== undefined)
+                    borders.innerVertical = buildBorder(args.innerVertical);
+                await sheets.spreadsheets.batchUpdate({
+                    spreadsheetId: args.spreadsheetId,
+                    requestBody: {
+                        requests: [{ updateBorders: { range: gridRange, ...borders } }],
+                    },
+                });
+                return `Successfully set borders on range "${args.range}".`;
+            }
+            catch (error) {
+                log.error(`Error setting borders: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to set borders: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/sheets/setColumnWidths.js

@@ -0,0 +1,43 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSheetsClient } from '../../clients.js';
+import * as SheetsHelpers from '../../googleSheetsApiHelpers.js';
+export function register(server) {
+    server.addTool({
+        name: 'setColumnWidths',
+        description: 'Sets the width (in pixels) of one or more columns in a spreadsheet. Accepts multiple column specs in a single call, each targeting a single column or a contiguous range (e.g., "A", "B:D").',
+        parameters: z.strictObject({
+            spreadsheetId: z
+                .string()
+                .describe('The spreadsheet ID — the long string between /d/ and /edit in a Google Sheets URL.'),
+            sheetName: z
+                .string()
+                .optional()
+                .describe('Name of the sheet/tab. Defaults to the first sheet if not provided.'),
+            columnWidths: z
+                .array(z.strictObject({
+                column: z
+                    .string()
+                    .describe('Column or column range in A1 notation (e.g., "A", "B:D").'),
+                width: z.number().int().min(0).describe('Width in pixels. Use 0 to hide the column.'),
+            }))
+                .min(1)
+                .describe('List of column width specifications to apply.'),
+        }),
+        execute: async (args, { log }) => {
+            const sheets = await getSheetsClient();
+            log.info(`Setting column widths in spreadsheet ${args.spreadsheetId}`);
+            try {
+                await SheetsHelpers.setColumnWidths(sheets, args.spreadsheetId, args.sheetName, args.columnWidths);
+                const summary = args.columnWidths.map((cw) => `${cw.column}=${cw.width}px`).join(', ');
+                return `Successfully set column widths: ${summary}.`;
+            }
+            catch (error) {
+                log.error(`Error setting column widths: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to set column widths: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/sheets/setDropdownValidation.js

@@ -0,0 +1,51 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSheetsClient } from '../../clients.js';
+import * as SheetsHelpers from '../../googleSheetsApiHelpers.js';
+export function register(server) {
+    server.addTool({
+        name: 'setDropdownValidation',
+        description: 'Adds or removes a dropdown list on a range of cells. Provide values to create a dropdown restricting input to those options. Omit values to remove dropdown validation from the range.',
+        parameters: z.strictObject({
+            spreadsheetId: z
+                .string()
+                .describe('The spreadsheet ID — the long string between /d/ and /edit in a Google Sheets URL.'),
+            range: z
+                .string()
+                .describe('A1 notation range to apply the dropdown to (e.g., "Sheet1!B2:B100" or "C2:C50").'),
+            values: z
+                .array(z.string())
+                .optional()
+                .describe('The allowed dropdown options (e.g., ["Open", "In Progress", "Done"]). Omit to remove existing dropdown validation from the range.'),
+            strict: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe('If true, reject input that does not match one of the dropdown values.'),
+            inputMessage: z
+                .string()
+                .optional()
+                .describe('Help text shown when a cell with the dropdown is selected.'),
+        }),
+        execute: async (args, { log }) => {
+            const sheets = await getSheetsClient();
+            const isClearing = !args.values || args.values.length === 0;
+            log.info(isClearing
+                ? `Clearing dropdown validation on "${args.range}" in spreadsheet ${args.spreadsheetId}`
+                : `Setting dropdown validation on "${args.range}" with ${args.values.length} options in spreadsheet ${args.spreadsheetId}`);
+            try {
+                await SheetsHelpers.setDropdownValidation(sheets, args.spreadsheetId, args.range, args.values, args.strict, args.inputMessage);
+                if (isClearing) {
+                    return `Successfully removed dropdown validation from range "${args.range}".`;
+                }
+                return `Successfully added dropdown validation to range "${args.range}" with ${args.values.length} options: ${args.values.join(', ')}.`;
+            }
+            catch (error) {
+                log.error(`Error setting dropdown validation: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to set dropdown validation: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/sheets/setRowHeights.js

@@ -0,0 +1,63 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSheetsClient } from '../../clients.js';
+import * as SheetsHelpers from '../../googleSheetsApiHelpers.js';
+export function register(server) {
+    server.addTool({
+        name: 'setRowHeights',
+        description: 'Sets a fixed pixel height for a range of rows in a spreadsheet. Useful for ensuring rows are tall enough to display wrapped text.',
+        parameters: z
+            .object({
+            spreadsheetId: z
+                .string()
+                .describe('The spreadsheet ID — the long string between /d/ and /edit in a Google Sheets URL.'),
+            sheetName: z
+                .string()
+                .optional()
+                .describe('Name of the sheet/tab. Defaults to the first sheet if not provided.'),
+            startRow: z.number().int().min(1).describe('1-based start row index (inclusive).'),
+            endRow: z.number().int().min(1).describe('1-based end row index (inclusive).'),
+            pixelSize: z
+                .number()
+                .int()
+                .min(2)
+                .describe('Height in pixels (e.g., 40 for comfortable single-line, 80 for two-line wrapped text).'),
+        })
+            .refine((d) => d.endRow >= d.startRow, {
+            message: 'endRow must be greater than or equal to startRow.',
+        }),
+        execute: async (args, { log }) => {
+            const sheets = await getSheetsClient();
+            log.info(`Setting row heights in spreadsheet ${args.spreadsheetId}`);
+            try {
+                const sheetId = await SheetsHelpers.resolveSheetId(sheets, args.spreadsheetId, args.sheetName);
+                await sheets.spreadsheets.batchUpdate({
+                    spreadsheetId: args.spreadsheetId,
+                    requestBody: {
+                        requests: [
+                            {
+                                updateDimensionProperties: {
+                                    range: {
+                                        sheetId,
+                                        dimension: 'ROWS',
+                                        startIndex: args.startRow - 1,
+                                        endIndex: args.endRow,
+                                    },
+                                    properties: { pixelSize: args.pixelSize },
+                                    fields: 'pixelSize',
+                                },
+                            },
+                        ],
+                    },
+                });
+                return `Successfully set rows ${args.startRow}–${args.endRow} to ${args.pixelSize}px height.`;
+            }
+            catch (error) {
+                log.error(`Error setting row heights: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to set row heights: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/sheets/ungroupAllRows.js

@@ -0,0 +1,66 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSheetsClient } from '../../clients.js';
+import * as SheetsHelpers from '../../googleSheetsApiHelpers.js';
+export function register(server) {
+    server.addTool({
+        name: 'ungroupAllRows',
+        description: 'Removes all row groupings from a sheet by deleting the entire row dimension group. Use before re-running groupRows to prevent duplicate collapse widgets from accumulating across report refreshes.',
+        parameters: z.strictObject({
+            spreadsheetId: z
+                .string()
+                .describe('The spreadsheet ID — the long string between /d/ and /edit in a Google Sheets URL.'),
+            sheetName: z
+                .string()
+                .optional()
+                .describe('Name of the sheet/tab. Defaults to the first sheet if not provided.'),
+            totalRows: z
+                .number()
+                .int()
+                .optional()
+                .default(500)
+                .describe('Number of rows to clear groups from (default: 500). Set higher if the sheet has more rows.'),
+        }),
+        execute: async (args, { log }) => {
+            const sheets = await getSheetsClient();
+            log.info(`Removing all row groups from spreadsheet ${args.spreadsheetId}`);
+            try {
+                const sheetId = await SheetsHelpers.resolveSheetId(sheets, args.spreadsheetId, args.sheetName);
+                const totalRows = args.totalRows ?? 500;
+                const request = {
+                    deleteDimensionGroup: {
+                        range: {
+                            sheetId,
+                            dimension: 'ROWS',
+                            startIndex: 0,
+                            endIndex: totalRows,
+                        },
+                    },
+                };
+                // deleteDimensionGroup removes one level at a time; call repeatedly until no groups remain
+                let removed = 0;
+                // eslint-disable-next-line no-constant-condition
+                while (true) {
+                    try {
+                        await sheets.spreadsheets.batchUpdate({
+                            spreadsheetId: args.spreadsheetId,
+                            requestBody: { requests: [request] },
+                        });
+                        removed++;
+                    }
+                    catch (err) {
+                        // When no groups remain the API returns an error — treat as done
+                        break;
+                    }
+                }
+                return `Successfully removed all row groups (${removed} level(s) cleared).`;
+            }
+            catch (error) {
+                log.error(`Error removing row groups: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to remove row groups: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}