@triffon/google-docs-mcp 1.11.3-triffon

package/dist/tools/sheets/comments/createSheetsComment.js

@@ -0,0 +1,168 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { google } from 'googleapis';
+import { getAuthClient, getSheetsClient } from '../../../clients.js';
+const CreateSheetsCommentParameters = z
+    .object({
+    spreadsheetId: z
+        .string()
+        .describe('The spreadsheet ID — the long string between /d/ and /edit in a Google Sheets URL.'),
+    content: z.string().min(1).describe('The text content of the comment.'),
+    sheetName: z
+        .string()
+        .optional()
+        .describe('Optional sheet/tab name for cell or range anchors that do not already include a sheet prefix.'),
+    cell: z
+        .string()
+        .optional()
+        .describe('Optional target cell in A1 notation (for example "B3" or "Sheet1!B3"). Used to quote the cell content and build a click-through link to that cell.'),
+    range: z
+        .string()
+        .optional()
+        .describe('Optional target range in A1 notation (for example "B3:D5" or "Sheet1!B3:D5"). The click-through link targets the full range.'),
+    includeCellLink: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('When a cell or range is given, appends a direct Google Sheets click-through URL (with gid and range) to the comment content so users can jump to the target cell/range. Defaults to true because the Drive API cannot natively anchor spreadsheet comments in the Sheets UI. Has no effect when no cell/range is provided.'),
+})
+    .refine((data) => !(data.cell && data.range), {
+    message: 'Provide either cell or range, not both.',
+    path: ['range'],
+})
+    .refine((data) => {
+    if (!data.cell && !data.range) {
+        return true;
+    }
+    if (data.sheetName) {
+        return true;
+    }
+    return hasSheetPrefix(data.cell ?? data.range ?? '');
+}, {
+    message: 'sheetName is required when cell or range does not include a sheet prefix.',
+    path: ['sheetName'],
+});
+export function register(server) {
+    server.addTool({
+        name: 'createSheetsComment',
+        description: 'Creates a new comment in a Google Spreadsheet. When you target a specific cell or range, a click-through link to that location is added to the comment body by default (includeCellLink), letting users jump to the cell. Note: the Drive API cannot natively anchor spreadsheet comments to a cell in the Sheets UI, so the comment itself appears under "All comments" — the click-through link is the supported way to navigate to the target.',
+        parameters: CreateSheetsCommentParameters,
+        execute: async (args, { log }) => {
+            log.info(`Creating spreadsheet comment in ${args.spreadsheetId}`);
+            try {
+                const authClient = await getAuthClient();
+                const drive = google.drive({ version: 'v3', auth: authClient });
+                const sheets = await getSheetsClient();
+                let quotedText;
+                let locationLabel;
+                let cellUrl;
+                if (args.cell || args.range) {
+                    const parsedLocation = parseLocation(args.cell ?? args.range ?? '', args.sheetName);
+                    const sheetId = await resolveSheetId(sheets, args.spreadsheetId, parsedLocation.sheetName);
+                    quotedText = await readRangeText(sheets, args.spreadsheetId, `${quoteSheetName(parsedLocation.sheetName)}!${parsedLocation.a1Range}`);
+                    locationLabel = `${parsedLocation.sheetName}!${parsedLocation.a1Range}`;
+                    cellUrl = buildCellUrl(args.spreadsheetId, sheetId, parsedLocation.a1Range);
+                }
+                const content = args.includeCellLink && cellUrl
+                    ? `${args.content}\n\n→ ${locationLabel}: ${cellUrl}`
+                    : args.content;
+                const response = await drive.comments.create({
+                    fileId: args.spreadsheetId,
+                    fields: 'id,quotedFileContent,createdTime',
+                    requestBody: {
+                        content,
+                        ...(quotedText
+                            ? {
+                                quotedFileContent: {
+                                    value: quotedText,
+                                    mimeType: 'text/plain',
+                                },
+                            }
+                            : {}),
+                    },
+                });
+                const linkNote = args.includeCellLink && cellUrl
+                    ? ` A click-through link to ${locationLabel} was added to the comment body so users can jump to the target cell.`
+                    : locationLabel
+                        ? ` Target location: ${locationLabel}.`
+                        : '';
+                return (`Comment added successfully. Comment ID: ${response.data.id}.` +
+                    linkNote +
+                    ' Note: the Drive API cannot natively anchor spreadsheet comments to a cell in the Sheets UI; use the click-through link to navigate to the location.');
+            }
+            catch (error) {
+                log.error(`Error creating sheets comment: ${error.message || error}`);
+                const errorDetails = error.response?.data?.error?.message || error.message || 'Unknown error';
+                throw new UserError(`Failed to create spreadsheet comment: ${errorDetails}`);
+            }
+        },
+    });
+}
+function buildCellUrl(spreadsheetId, sheetId, a1Range) {
+    return `https://docs.google.com/spreadsheets/d/${spreadsheetId}/edit#gid=${sheetId}&range=${encodeURIComponent(a1Range)}`;
+}
+function hasSheetPrefix(value) {
+    return value.includes('!');
+}
+function parseLocation(value, fallbackSheetName) {
+    const bangIndex = value.lastIndexOf('!');
+    const rawSheetName = bangIndex >= 0 ? unquoteSheetName(value.slice(0, bangIndex)) : fallbackSheetName;
+    const a1Range = bangIndex >= 0 ? value.slice(bangIndex + 1) : value;
+    if (!rawSheetName) {
+        throw new UserError('Could not determine the target sheet name for the spreadsheet comment.');
+    }
+    // Validate the start cell is a well-formed A1 reference (fail early on bad input).
+    const startCell = a1Range.split(':')[0];
+    validateA1Cell(startCell);
+    return {
+        sheetName: rawSheetName,
+        a1Range,
+    };
+}
+function validateA1Cell(a1) {
+    const match = a1.trim().match(/^([A-Za-z]+)(\d+)$/);
+    if (!match) {
+        throw new UserError(`Invalid A1 cell reference: ${a1}`);
+    }
+}
+function unquoteSheetName(sheetName) {
+    const trimmed = sheetName.trim();
+    if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
+        return trimmed.slice(1, -1).replace(/''/g, "'");
+    }
+    return trimmed;
+}
+function quoteSheetName(sheetName) {
+    return `'${sheetName.replace(/'/g, "''")}'`;
+}
+async function resolveSheetId(sheets, spreadsheetId, sheetName) {
+    const response = await sheets.spreadsheets.get({
+        spreadsheetId,
+        fields: 'sheets.properties(sheetId,title)',
+    });
+    for (const sheet of response.data.sheets || []) {
+        const props = sheet.properties;
+        if (props?.title === sheetName && props.sheetId != null) {
+            return props.sheetId;
+        }
+    }
+    throw new UserError(`Sheet "${sheetName}" was not found in spreadsheet ${spreadsheetId}.`);
+}
+async function readRangeText(sheets, spreadsheetId, range) {
+    const response = await sheets.spreadsheets.values.get({
+        spreadsheetId,
+        range,
+        valueRenderOption: 'FORMATTED_VALUE',
+    });
+    const values = response.data.values || [];
+    if (values.length === 0) {
+        return undefined;
+    }
+    const lines = values
+        .map((row) => row
+        .map((cell) => String(cell))
+        .join('\t')
+        .trimEnd())
+        .filter((line) => line.length > 0);
+    return lines.length > 0 ? lines.join('\n') : undefined;
+}

package/dist/tools/sheets/comments/deleteSheetsComment.js

@@ -0,0 +1,32 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { google } from 'googleapis';
+import { getAuthClient } from '../../../clients.js';
+export function register(server) {
+    server.addTool({
+        name: 'deleteSheetsComment',
+        description: 'Permanently deletes a comment and all its replies from a Google Spreadsheet.',
+        parameters: z.strictObject({
+            spreadsheetId: z
+                .string()
+                .describe('The spreadsheet ID — the long string between /d/ and /edit in a Google Sheets URL.'),
+            commentId: z.string().describe('The ID of the comment to delete.'),
+        }),
+        execute: async (args, { log }) => {
+            log.info(`Deleting comment ${args.commentId} from spreadsheet ${args.spreadsheetId}`);
+            try {
+                const authClient = await getAuthClient();
+                const drive = google.drive({ version: 'v3', auth: authClient });
+                await drive.comments.delete({
+                    fileId: args.spreadsheetId,
+                    commentId: args.commentId,
+                });
+                return `Comment ${args.commentId} has been deleted.`;
+            }
+            catch (error) {
+                log.error(`Error deleting sheets comment: ${error.message || error}`);
+                throw new UserError(`Failed to delete comment: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/sheets/comments/getSheetsComment.js

@@ -0,0 +1,51 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { google } from 'googleapis';
+import { getAuthClient } from '../../../clients.js';
+import { extractCommentLocation, rowColToA1 } from './commentAnchor.js';
+export function register(server) {
+    server.addTool({
+        name: 'getSheetsComment',
+        description: 'Gets a specific comment and its full reply thread from a Google Spreadsheet. Use listSheetsComments first to find the comment ID.',
+        parameters: z.strictObject({
+            spreadsheetId: z
+                .string()
+                .describe('The spreadsheet ID — the long string between /d/ and /edit in a Google Sheets URL.'),
+            commentId: z.string().describe('The ID of the comment to retrieve.'),
+        }),
+        execute: async (args, { log }) => {
+            log.info(`Getting comment ${args.commentId} from spreadsheet ${args.spreadsheetId}`);
+            try {
+                const authClient = await getAuthClient();
+                const drive = google.drive({ version: 'v3', auth: authClient });
+                const response = await drive.comments.get({
+                    fileId: args.spreadsheetId,
+                    commentId: args.commentId,
+                    fields: 'id,content,anchor,quotedFileContent,author,createdTime,modifiedTime,resolved,replies(id,content,author,createdTime)',
+                });
+                const comment = response.data;
+                const cellInfo = extractCommentLocation(comment);
+                return JSON.stringify({
+                    id: comment.id,
+                    author: comment.author?.displayName || null,
+                    content: comment.content,
+                    cell: cellInfo ? rowColToA1(cellInfo.row, cellInfo.col) : null,
+                    quotedText: comment.quotedFileContent?.value || null,
+                    resolved: comment.resolved || false,
+                    createdTime: comment.createdTime,
+                    modifiedTime: comment.modifiedTime,
+                    replies: (comment.replies || []).map((r) => ({
+                        id: r.id,
+                        author: r.author?.displayName || null,
+                        content: r.content,
+                        createdTime: r.createdTime,
+                    })),
+                }, null, 2);
+            }
+            catch (error) {
+                log.error(`Error getting sheets comment: ${error.message || error}`);
+                throw new UserError(`Failed to get comment: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/sheets/comments/index.js

@@ -0,0 +1,16 @@
+import { register as createSheetsComment } from './createSheetsComment.js';
+import { register as createSheetsCellNote } from './createSheetsCellNote.js';
+import { register as listSheetsComments } from './listSheetsComments.js';
+import { register as getSheetsComment } from './getSheetsComment.js';
+import { register as replyToSheetsComment } from './replyToSheetsComment.js';
+import { register as resolveSheetsComment } from './resolveSheetsComment.js';
+import { register as deleteSheetsComment } from './deleteSheetsComment.js';
+export function registerSheetsCommentTools(server) {
+    createSheetsComment(server);
+    createSheetsCellNote(server);
+    listSheetsComments(server);
+    getSheetsComment(server);
+    replyToSheetsComment(server);
+    resolveSheetsComment(server);
+    deleteSheetsComment(server);
+}

package/dist/tools/sheets/comments/listSheetsComments.js

@@ -0,0 +1,177 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { google } from 'googleapis';
+import { getAuthClient, getSheetsClient } from '../../../clients.js';
+import { extractCommentLocation, a1ToRowCol, rowColToA1 } from './commentAnchor.js';
+export function register(server) {
+    server.addTool({
+        name: 'listSheetsComments',
+        description: 'Lists all comments in a Google Spreadsheet. Filter by sheet name, specific row(s), specific cell, or a cell range. Returns comment IDs needed for getSheetsComment, replyToSheetsComment, resolveSheetsComment, or deleteSheetsComment.',
+        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 comments to only this sheet/tab name.'),
+            row: z
+                .number()
+                .int()
+                .min(1)
+                .optional()
+                .describe('Optional: filter to comments on this specific row number (1-based, e.g., 5 for row 5).'),
+            rows: z
+                .array(z.number().int().min(1))
+                .optional()
+                .describe('Optional: filter to comments on any of these row numbers (1-based, e.g., [3, 5, 12]). Ignored if "row" is set.'),
+            cell: z
+                .string()
+                .optional()
+                .describe('Optional: filter to comments on this specific cell in A1 notation (e.g., "B3"). Overrides row/rows filters.'),
+            range: z
+                .string()
+                .optional()
+                .describe('Optional: filter to comments within this A1 range (e.g., "A1:D10", "B:B" for entire column B). Overrides row/rows/cell filters.'),
+            includeResolved: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe('If true, include resolved comments. Defaults to false.'),
+        }),
+        execute: async (args, { log }) => {
+            log.info(`Listing comments for spreadsheet ${args.spreadsheetId}`);
+            try {
+                const authClient = await getAuthClient();
+                const drive = google.drive({ version: 'v3', auth: authClient });
+                const comments = [];
+                let pageToken;
+                do {
+                    const response = await drive.comments.list({
+                        fileId: args.spreadsheetId,
+                        fields: 'comments(id,content,anchor,quotedFileContent,author,createdTime,modifiedTime,resolved,replies(id,content,author,createdTime)),nextPageToken',
+                        pageSize: 100,
+                        ...(pageToken ? { pageToken } : {}),
+                    });
+                    comments.push(...(response.data.comments || []));
+                    pageToken = response.data.nextPageToken || undefined;
+                } while (pageToken);
+                let sheetGidMap = {};
+                const needSheetMeta = args.sheetName || args.row || args.rows || args.cell || args.range;
+                if (needSheetMeta) {
+                    const sheetsClient = await getSheetsClient();
+                    const meta = await sheetsClient.spreadsheets.get({
+                        spreadsheetId: args.spreadsheetId,
+                        fields: 'sheets.properties',
+                    });
+                    for (const sheet of meta.data.sheets || []) {
+                        const props = sheet.properties;
+                        if (props?.sheetId !== undefined && props?.title) {
+                            sheetGidMap[String(props.sheetId)] = props.title;
+                        }
+                    }
+                }
+                const rangeFilter = args.range ? parseA1Range(args.range) : null;
+                const cellFilter = args.cell ? a1ToRowCol(args.cell) : null;
+                const rowSet = args.row
+                    ? new Set([args.row - 1])
+                    : args.rows
+                        ? new Set(args.rows.map((r) => r - 1))
+                        : null;
+                const result = comments
+                    .filter((c) => {
+                    if (!args.includeResolved && c.resolved)
+                        return false;
+                    const cellInfo = extractCommentLocation(c);
+                    if (args.sheetName && cellInfo) {
+                        const resolvedName = sheetGidMap[String(cellInfo.sheetId)];
+                        if (resolvedName && resolvedName !== args.sheetName)
+                            return false;
+                    }
+                    if (!cellInfo)
+                        return !rangeFilter && !cellFilter && !rowSet;
+                    if (rangeFilter) {
+                        return (cellInfo.row >= rangeFilter.startRow &&
+                            cellInfo.row <= rangeFilter.endRow &&
+                            cellInfo.col >= rangeFilter.startCol &&
+                            cellInfo.col <= rangeFilter.endCol);
+                    }
+                    if (cellFilter) {
+                        return cellInfo.row === cellFilter.row && cellInfo.col === cellFilter.col;
+                    }
+                    // Guard: a malformed cell arg yields a null cellFilter; fall through
+                    // means no cell constraint applied, which matches prior behavior.
+                    if (rowSet) {
+                        return rowSet.has(cellInfo.row);
+                    }
+                    return true;
+                })
+                    .map((comment) => {
+                    const cellInfo = extractCommentLocation(comment);
+                    let cellRef = null;
+                    let sheetTitle = null;
+                    if (cellInfo) {
+                        cellRef = rowColToA1(cellInfo.row, cellInfo.col);
+                        if (Object.keys(sheetGidMap).length > 0) {
+                            sheetTitle = sheetGidMap[String(cellInfo.sheetId)] || null;
+                        }
+                    }
+                    return {
+                        id: comment.id,
+                        author: comment.author?.displayName || null,
+                        content: comment.content,
+                        cell: cellRef,
+                        sheetName: sheetTitle,
+                        quotedText: comment.quotedFileContent?.value || null,
+                        resolved: comment.resolved || false,
+                        createdTime: comment.createdTime,
+                        modifiedTime: comment.modifiedTime,
+                        replyCount: comment.replies?.length || 0,
+                    };
+                });
+                return JSON.stringify({ comments: result, total: result.length }, null, 2);
+            }
+            catch (error) {
+                log.error(`Error listing sheets comments: ${error.message || error}`);
+                throw new UserError(`Failed to list spreadsheet comments: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}
+function parseA1Range(range) {
+    const stripped = range.includes('!') ? range.split('!')[1] : range;
+    const parts = stripped.split(':');
+    const colOnly = /^[A-Za-z]+$/;
+    const rowOnly = /^\d+$/;
+    const parseCorner = (s) => {
+        if (colOnly.test(s)) {
+            const upper = s.toUpperCase();
+            let c = 0;
+            for (let i = 0; i < upper.length; i++)
+                c = c * 26 + (upper.charCodeAt(i) - 64);
+            return { row: null, col: c - 1 };
+        }
+        if (rowOnly.test(s)) {
+            return { row: parseInt(s, 10) - 1, col: null };
+        }
+        const rc = a1ToRowCol(s);
+        return rc ? { row: rc.row, col: rc.col } : { row: null, col: null };
+    };
+    if (parts.length === 1) {
+        const p = parseCorner(parts[0]);
+        return {
+            startRow: p.row ?? 0,
+            endRow: p.row ?? 999999,
+            startCol: p.col ?? 0,
+            endCol: p.col ?? 999999,
+        };
+    }
+    const start = parseCorner(parts[0]);
+    const end = parseCorner(parts[1]);
+    return {
+        startRow: start.row ?? 0,
+        endRow: end.row ?? 999999,
+        startCol: start.col ?? 0,
+        endCol: end.col ?? 999999,
+    };
+}

package/dist/tools/sheets/comments/replyToSheetsComment.js

@@ -0,0 +1,37 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { google } from 'googleapis';
+import { getAuthClient } from '../../../clients.js';
+export function register(server) {
+    server.addTool({
+        name: 'replyToSheetsComment',
+        description: 'Adds a reply to an existing comment thread in a Google Spreadsheet. Use listSheetsComments or getSheetsComment to find the comment ID.',
+        parameters: z.strictObject({
+            spreadsheetId: z
+                .string()
+                .describe('The spreadsheet ID — the long string between /d/ and /edit in a Google Sheets URL.'),
+            commentId: z.string().describe('The ID of the comment to reply to.'),
+            content: z.string().min(1).describe('The text content of the reply.'),
+        }),
+        execute: async (args, { log }) => {
+            log.info(`Adding reply to comment ${args.commentId} in spreadsheet ${args.spreadsheetId}`);
+            try {
+                const authClient = await getAuthClient();
+                const drive = google.drive({ version: 'v3', auth: authClient });
+                const response = await drive.replies.create({
+                    fileId: args.spreadsheetId,
+                    commentId: args.commentId,
+                    fields: 'id,content,author,createdTime',
+                    requestBody: {
+                        content: args.content,
+                    },
+                });
+                return `Reply added successfully. Reply ID: ${response.data.id}`;
+            }
+            catch (error) {
+                log.error(`Error adding reply to sheets comment: ${error.message || error}`);
+                throw new UserError(`Failed to add reply: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/sheets/comments/resolveSheetsComment.js

@@ -0,0 +1,53 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { google } from 'googleapis';
+import { getAuthClient } from '../../../clients.js';
+export function register(server) {
+    server.addTool({
+        name: 'resolveSheetsComment',
+        description: 'Marks a comment as resolved in a Google Spreadsheet. Note: resolved status may not persist in the Sheets UI due to a Drive API limitation.',
+        parameters: z.strictObject({
+            spreadsheetId: z
+                .string()
+                .describe('The spreadsheet ID — the long string between /d/ and /edit in a Google Sheets URL.'),
+            commentId: z.string().describe('The ID of the comment to resolve.'),
+        }),
+        execute: async (args, { log }) => {
+            log.info(`Resolving comment ${args.commentId} in spreadsheet ${args.spreadsheetId}`);
+            try {
+                const authClient = await getAuthClient();
+                const drive = google.drive({ version: 'v3', auth: authClient });
+                const currentComment = await drive.comments.get({
+                    fileId: args.spreadsheetId,
+                    commentId: args.commentId,
+                    fields: 'content',
+                });
+                await drive.comments.update({
+                    fileId: args.spreadsheetId,
+                    commentId: args.commentId,
+                    fields: 'id,resolved',
+                    requestBody: {
+                        content: currentComment.data.content,
+                        resolved: true,
+                    },
+                });
+                const verifyComment = await drive.comments.get({
+                    fileId: args.spreadsheetId,
+                    commentId: args.commentId,
+                    fields: 'resolved',
+                });
+                if (verifyComment.data.resolved) {
+                    return `Comment ${args.commentId} has been marked as resolved.`;
+                }
+                else {
+                    return `Attempted to resolve comment ${args.commentId}, but the resolved status may not persist in the Sheets UI due to API limitations. The comment can be resolved manually in the Google Sheets interface.`;
+                }
+            }
+            catch (error) {
+                log.error(`Error resolving sheets comment: ${error.message || error}`);
+                const errorDetails = error.response?.data?.error?.message || error.message || 'Unknown error';
+                throw new UserError(`Failed to resolve comment: ${errorDetails}`);
+            }
+        },
+    });
+}

package/dist/tools/sheets/copyFormatting.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: 'copyFormatting',
+        description: 'Copies formatting (not values) from a source range to a destination range within the same spreadsheet. Copies bold, colors, borders, number formats, etc.',
+        parameters: z.strictObject({
+            spreadsheetId: z
+                .string()
+                .describe('The spreadsheet ID — the long string between /d/ and /edit in a Google Sheets URL.'),
+            sourceSheetName: z.string().min(1).describe('Source sheet/tab name (e.g., "Sheet1").'),
+            sourceRange: z
+                .string()
+                .describe('A1 notation for the source range (e.g., "A1:D10"). Do not include the sheet name — use sourceSheetName instead.'),
+            destinationSheetName: z
+                .string()
+                .min(1)
+                .describe('Destination sheet/tab name (e.g., "Sheet2").'),
+            destinationRange: z
+                .string()
+                .describe('A1 notation for the destination range (e.g., "A1:D10"). Do not include the sheet name — use destinationSheetName instead.'),
+        }),
+        execute: async (args, { log }) => {
+            const sheets = await getSheetsClient();
+            log.info(`Copying formatting from ${args.sourceSheetName}!${args.sourceRange} to ${args.destinationSheetName}!${args.destinationRange} in spreadsheet ${args.spreadsheetId}`);
+            try {
+                // Resolve sheet names to numeric IDs
+                const sourceSheetId = await SheetsHelpers.resolveSheetId(sheets, args.spreadsheetId, args.sourceSheetName);
+                const destSheetId = await SheetsHelpers.resolveSheetId(sheets, args.spreadsheetId, args.destinationSheetName);
+                // Convert A1 ranges to GridRange objects
+                const sourceGridRange = SheetsHelpers.parseA1ToGridRange(args.sourceRange, sourceSheetId);
+                const destGridRange = SheetsHelpers.parseA1ToGridRange(args.destinationRange, destSheetId);
+                await sheets.spreadsheets.batchUpdate({
+                    spreadsheetId: args.spreadsheetId,
+                    requestBody: {
+                        requests: [
+                            {
+                                copyPaste: {
+                                    source: sourceGridRange,
+                                    destination: destGridRange,
+                                    pasteType: 'PASTE_FORMAT',
+                                },
+                            },
+                        ],
+                    },
+                });
+                return `Successfully copied formatting from ${args.sourceSheetName}!${args.sourceRange} to ${args.destinationSheetName}!${args.destinationRange}.`;
+            }
+            catch (error) {
+                log.error(`Error copying formatting in spreadsheet ${args.spreadsheetId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to copy formatting: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/sheets/copySheetTo.js

@@ -0,0 +1,36 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSheetsClient } from '../../clients.js';
+export function register(server) {
+    server.addTool({
+        name: 'copySheetTo',
+        description: 'Copies a sheet (tab) from one spreadsheet to another spreadsheet. Use getSpreadsheetInfo to find the numeric sheet ID. The copied sheet will be appended to the destination spreadsheet.',
+        parameters: z.strictObject({
+            sourceSpreadsheetId: z.string().describe('The spreadsheet ID of the source file.'),
+            sheetId: z
+                .number()
+                .int()
+                .describe('The numeric sheet ID to copy. Use getSpreadsheetInfo to find sheet IDs.'),
+            destinationSpreadsheetId: z.string().describe('The spreadsheet ID of the destination file.'),
+        }),
+        execute: async (args, { log }) => {
+            const sheets = await getSheetsClient();
+            log.info(`Copying sheet ${args.sheetId} from ${args.sourceSpreadsheetId} to ${args.destinationSpreadsheetId}`);
+            try {
+                const response = await sheets.spreadsheets.sheets.copyTo({
+                    spreadsheetId: args.sourceSpreadsheetId,
+                    sheetId: args.sheetId,
+                    requestBody: { destinationSpreadsheetId: args.destinationSpreadsheetId },
+                });
+                const props = response.data;
+                return `Successfully copied sheet to destination as "${props.title}" (Sheet ID: ${props.sheetId}).`;
+            }
+            catch (error) {
+                log.error(`Error copying sheet: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to copy sheet: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}