google-tools-mcp 1.0.16 → 1.1.1

package/dist/tools/extras/readDriveFile.js

@@ -0,0 +1,206 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDriveClient, getDocsClient, getSheetsClient } from '../../clients.js';
+import { docsJsonToMarkdown } from '../../markdown-transformer/index.js';
+import * as GDocsHelpers from '../../googleDocsApiHelpers.js';
+import { extractText, downloadBuffer } from './readFile.js';
+import { trackRead } from '../../readTracker.js';
+
+// Google-native MIME types
+const GOOGLE_DOC = 'application/vnd.google-apps.document';
+const GOOGLE_SHEET = 'application/vnd.google-apps.spreadsheet';
+const GOOGLE_SLIDES = 'application/vnd.google-apps.presentation';
+
+// Capabilities by file type category
+const CAPABILITIES = {
+    googleDoc: {
+        fileType: 'Google Doc',
+        capabilities: ['read', 'readDocument', 'modifyText', 'replaceDocumentWithMarkdown', 'appendMarkdown', 'appendText', 'findAndReplace', 'deleteRange'],
+    },
+    googleSheet: {
+        fileType: 'Google Sheet',
+        capabilities: ['read', 'readSpreadsheet', 'writeSpreadsheet', 'appendRows', 'formatCells'],
+    },
+    docx: {
+        fileType: 'Word Document (.docx)',
+        capabilities: ['read'],
+        note: 'This is a Word document. Editing tools (modifyText, appendMarkdown, etc.) are not available unless converted to a Google Doc via copyFile or Drive UI.',
+    },
+    pdf: {
+        fileType: 'PDF',
+        capabilities: ['read'],
+        note: 'This is a PDF file. Editing tools are not available. Convert to a Google Doc first if editing is needed.',
+    },
+    other: {
+        fileType: 'Unknown',
+        capabilities: ['download'],
+        note: 'This file type cannot be read as text. Use downloadFile to download it.',
+    },
+};
+
+export function register(server) {
+    server.addTool({
+        name: 'readDriveFile',
+        description:
+            'Unified read tool: accepts any Google Drive file ID, auto-detects the file type (Google Doc, Sheet, Word .docx, PDF), ' +
+            'and routes to the appropriate reader. Returns content along with metadata about available capabilities. ' +
+            'Use this when you have a file ID but don\'t know the file type, or when readDocument fails with a 400 error.',
+        parameters: z.object({
+            fileId: z
+                .string()
+                .describe('The Google Drive file ID (the long string between /d/ and /edit in a Drive URL).'),
+            format: z
+                .enum(['text', 'json', 'markdown'])
+                .optional()
+                .default('markdown')
+                .describe("Output format for Google Docs: 'markdown' (default), 'text' (plain text), 'json' (raw structure). Ignored for non-Doc files."),
+            range: z
+                .string()
+                .optional()
+                .describe("A1 notation range for Google Sheets (e.g., 'Sheet1!A1:C10'). Required for spreadsheets."),
+        }),
+        execute: async (args, { log }) => {
+            const drive = await getDriveClient();
+
+            // 1. Get file metadata to determine type
+            let fileMeta;
+            try {
+                const res = await drive.files.get({
+                    fileId: args.fileId,
+                    fields: 'id,name,mimeType,modifiedTime,size',
+                    supportsAllDrives: true,
+                });
+                fileMeta = res.data;
+            } catch (error) {
+                if (error.code === 404) throw new UserError(`File not found: ${args.fileId}`);
+                if (error.code === 403) throw new UserError('Permission denied. Check that the file is shared with this account.');
+                throw new UserError(`Failed to get file info: ${error.message}`);
+            }
+
+            log.info(`File "${fileMeta.name}" is ${fileMeta.mimeType}`);
+            trackRead(args.fileId, fileMeta.modifiedTime);
+
+            // 2. Route based on MIME type
+            if (fileMeta.mimeType === GOOGLE_DOC) {
+                return await readGoogleDoc(args, fileMeta, log);
+            }
+
+            if (fileMeta.mimeType === GOOGLE_SHEET) {
+                return await readGoogleSheet(args, fileMeta, log);
+            }
+
+            // Try reading as docx/pdf
+            const text = await tryReadBinaryFile(drive, args.fileId, fileMeta, log);
+            if (text !== null) {
+                return text;
+            }
+
+            // Unsupported type
+            const capInfo = CAPABILITIES.other;
+            capInfo.fileType = fileMeta.mimeType;
+            return JSON.stringify({
+                file: { id: fileMeta.id, name: fileMeta.name, mimeType: fileMeta.mimeType },
+                ...capInfo,
+                content: null,
+            }, null, 2);
+        },
+    });
+}
+
+async function readGoogleDoc(args, fileMeta, log) {
+    const docs = await getDocsClient();
+    const res = await docs.documents.get({
+        documentId: args.fileId,
+        fields: args.format === 'text' ? 'body(content(paragraph(elements(textRun(content)))))' : '*',
+    });
+
+    let content;
+    if (args.format === 'json') {
+        content = JSON.stringify(res.data, null, 2);
+    } else if (args.format === 'markdown') {
+        content = docsJsonToMarkdown(res.data);
+    } else {
+        // text
+        let textContent = '';
+        res.data.body?.content?.forEach((element) => {
+            if (element.paragraph?.elements) {
+                element.paragraph.elements.forEach((pe) => {
+                    if (pe.textRun?.content) textContent += pe.textRun.content;
+                });
+            }
+            if (element.table?.tableRows) {
+                element.table.tableRows.forEach((row) => {
+                    row.tableCells?.forEach((cell) => {
+                        cell.content?.forEach((cellElement) => {
+                            cellElement.paragraph?.elements?.forEach((pe) => {
+                                if (pe.textRun?.content) textContent += pe.textRun.content;
+                            });
+                        });
+                    });
+                });
+            }
+        });
+        content = textContent || '(empty document)';
+    }
+
+    return JSON.stringify({
+        file: { id: fileMeta.id, name: fileMeta.name, mimeType: fileMeta.mimeType },
+        ...CAPABILITIES.googleDoc,
+        content,
+    }, null, 2);
+}
+
+async function readGoogleSheet(args, fileMeta, log) {
+    if (!args.range) {
+        // Return sheet info without data
+        const sheets = await getSheetsClient();
+        const info = await sheets.spreadsheets.get({
+            spreadsheetId: args.fileId,
+            fields: 'sheets(properties(sheetId,title,gridProperties))',
+        });
+        const sheetList = info.data.sheets?.map(s => ({
+            title: s.properties.title,
+            sheetId: s.properties.sheetId,
+            rows: s.properties.gridProperties?.rowCount,
+            cols: s.properties.gridProperties?.columnCount,
+        }));
+        return JSON.stringify({
+            file: { id: fileMeta.id, name: fileMeta.name, mimeType: fileMeta.mimeType },
+            ...CAPABILITIES.googleSheet,
+            note: 'Provide a range parameter (e.g., "Sheet1!A1:C10") to read data. Available sheets listed below.',
+            sheets: sheetList,
+        }, null, 2);
+    }
+
+    const sheets = await getSheetsClient();
+    const response = await sheets.spreadsheets.values.get({
+        spreadsheetId: args.fileId,
+        range: args.range,
+    });
+    return JSON.stringify({
+        file: { id: fileMeta.id, name: fileMeta.name, mimeType: fileMeta.mimeType },
+        ...CAPABILITIES.googleSheet,
+        range: args.range,
+        values: response.data.values || [],
+    }, null, 2);
+}
+
+async function tryReadBinaryFile(drive, fileId, fileMeta, log) {
+    const { mimeType, name } = fileMeta;
+    const isDocxFile = mimeType === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' || name?.endsWith('.docx');
+    const isPdfFile = mimeType === 'application/pdf' || name?.endsWith('.pdf');
+
+    if (!isDocxFile && !isPdfFile) return null;
+
+    const buffer = await downloadBuffer(drive, fileId);
+    const text = await extractText(buffer, mimeType, name);
+
+    if (text === null) return null;
+
+    const capInfo = isDocxFile ? CAPABILITIES.docx : CAPABILITIES.pdf;
+    return JSON.stringify({
+        file: { id: fileMeta.id, name: fileMeta.name, mimeType: fileMeta.mimeType },
+        ...capInfo,
+        content: text,
+    }, null, 2);
+}

package/dist/tools/extras/readFile.js

@@ -1,6 +1,7 @@
 import { UserError } from 'fastmcp';
 import { z } from 'zod';
 import { getDriveClient } from '../../clients.js';
+import { trackRead } from '../../readTracker.js';
 import mammoth from 'mammoth';
 
 function isDocx(mimeType, name) {
@@ -58,6 +59,7 @@ export function register(server) {
                 });
 
                 const { name, mimeType } = meta.data;
+                trackRead(fileId);
                 const buffer = await downloadBuffer(drive, fileId);
                 const text = await extractText(buffer, mimeType, name);
 

package/dist/tools/forms/batchUpdateForm.js

@@ -49,6 +49,7 @@ export function register(server) {
                 const replies = data.replies || [];
 
                 const result = {
+                    url: `https://docs.google.com/forms/d/${args.formId}/edit`,
                     requestsApplied: args.requests.length,
                     repliesReceived: replies.length,
                 };

package/dist/tools/forms/setPublishSettings.js

@@ -41,6 +41,7 @@ export function register(server) {
                 });
 
                 return JSON.stringify({
+                    url: `https://docs.google.com/forms/d/${args.formId}/edit`,
                     success: true,
                     formId: args.formId,
                     message: 'Publish settings updated successfully.',

package/dist/tools/index.js

@@ -6,21 +6,103 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import * as os from 'os';
+import { exec } from 'child_process';
+import { promisify } from 'util';
 import { getTokenPath, getConfigDir, SCOPES } from '../auth.js';
 import { resetClients, withAuthRetry, getAuthClientIfReady } from '../clients.js';
 import { logger } from '../logger.js';
 import { google } from 'googleapis';
 
+const execAsync = promisify(exec);
+
+const REPO = 'karthikcsq/google-tools-mcp';
+
+async function tryGhCli(title, body, label) {
+    // Probe for gh CLI
+    try {
+        await execAsync('gh --version');
+    } catch {
+        return { ok: false, reason: 'gh CLI not installed' };
+    }
+    // Probe for auth
+    try {
+        await execAsync('gh auth status');
+    } catch {
+        return { ok: false, reason: 'gh CLI not authenticated (run: gh auth login)' };
+    }
+    // Write body to a temp file to avoid shell-escaping issues with newlines/quotes.
+    const tmpFile = path.join(os.tmpdir(), `gtm-feedback-${Date.now()}-${Math.random().toString(36).slice(2)}.md`);
+    try {
+        await fs.writeFile(tmpFile, body, 'utf8');
+        const { stdout } = await execAsync(
+            `gh issue create --repo ${REPO} --title ${JSON.stringify(title)} --label ${JSON.stringify(label)} --body-file ${JSON.stringify(tmpFile)}`,
+            { maxBuffer: 10 * 1024 * 1024 }
+        );
+        const issueUrl = stdout.trim().split('\n').pop();
+        return { ok: true, issueUrl };
+    } catch (err) {
+        return { ok: false, reason: `gh CLI failed: ${err.stderr || err.message || err}` };
+    } finally {
+        try { await fs.unlink(tmpFile); } catch {}
+    }
+}
+
+function openBrowser(url) {
+    const platform = process.platform;
+    let cmd;
+    if (platform === 'win32') {
+        cmd = `start "" "${url}"`;
+    } else if (platform === 'darwin') {
+        cmd = `open "${url}"`;
+    } else {
+        cmd = `xdg-open "${url}"`;
+    }
+    return new Promise((resolve) => {
+        exec(cmd, (err) => resolve(!err));
+    });
+}
+
 // ---------------------------------------------------------------------------
-// Wrap server.addTool so every tool's execute() auto-retries on invalid_grant.
+// Wrap server.addTool so every tool's execute() auto-retries on invalid_grant
+// and appends a troubleshoot/feedback hint to errors.
 // ---------------------------------------------------------------------------
+const ERROR_HINT =
+    '\n\nIf this error is unexpected or unclear, you can:\n' +
+    '  • Call the `troubleshoot` tool to run a health check (auth, API connectivity, recent logs).\n' +
+    '  • Call the `feedback` tool to file a bug report with diagnostics auto-attached.';
+
+// Tools that should NOT have the hint appended (would be circular/noisy).
+const HINT_EXCLUDED_TOOLS = new Set(['troubleshoot', 'feedback', 'help', 'logout']);
+
+function appendHintToError(error, toolName) {
+    if (HINT_EXCLUDED_TOOLS.has(toolName)) return error;
+    if (!error) return error;
+    // Avoid double-appending if something else (or a retry) already added it.
+    const existingMsg = error.message || '';
+    if (existingMsg.includes('`troubleshoot` tool')) return error;
+    try {
+        error.message = existingMsg + ERROR_HINT;
+    } catch {
+        // Some error types have non-writable message; fall back to a new error.
+        const wrapped = new Error(existingMsg + ERROR_HINT);
+        wrapped.cause = error;
+        return wrapped;
+    }
+    return error;
+}
+
 function wrapServerWithAuthRetry(server) {
     const originalAddTool = server.addTool.bind(server);
     server.addTool = function (toolDef) {
         const originalExecute = toolDef.execute;
+        const toolName = toolDef.name;
         if (originalExecute) {
-            toolDef.execute = function (...args) {
-                return withAuthRetry(() => originalExecute.apply(this, args));
+            toolDef.execute = async function (...args) {
+                try {
+                    return await withAuthRetry(() => originalExecute.apply(this, args));
+                } catch (err) {
+                    throw appendHintToError(err, toolName);
+                }
             };
         }
         return originalAddTool(toolDef);
@@ -109,15 +191,22 @@ export async function registerAllTools(server) {
     server.addTool({
         name: 'help',
         description:
-            'Show documentation for google-tools-mcp: setup instructions, available tool categories, environment variables, and troubleshooting. Call this when you need guidance on how to use the Google Workspace tools.',
+            'Show documentation for google-tools-mcp: setup instructions, available tool categories, environment variables, and troubleshooting. ' +
+            'Call this when you need guidance on how to use the Google Workspace tools. ' +
+            'Also available: `troubleshoot` (run health check when tools fail) and `feedback` (submit bug reports/feature requests with diagnostics auto-attached).',
         parameters: z.object({}),
         execute: async () => {
             const __dirname = path.dirname(fileURLToPath(import.meta.url));
             const readmePath = path.resolve(__dirname, '..', '..', 'README.md');
+            const diagnosticsSection = '\n\n## Diagnostics & Feedback\n\n' +
+                '- **`troubleshoot`** — Run a health check when tools fail (checks auth, API connectivity, config, recent logs).\n' +
+                '- **`feedback`** — Submit a bug report or feature request with diagnostics auto-attached (files via GitHub CLI or browser).\n' +
+                '- **`help`** — Show this documentation.\n';
             try {
-                return await fs.readFile(readmePath, 'utf-8');
+                const readme = await fs.readFile(readmePath, 'utf-8');
+                return readme + diagnosticsSection;
             } catch {
-                return 'README not found. Visit https://www.npmjs.com/package/google-tools-mcp for documentation.';
+                return 'README not found. Visit https://www.npmjs.com/package/google-tools-mcp for documentation.' + diagnosticsSection;
             }
         },
     });
@@ -275,7 +364,7 @@ export async function registerAllTools(server) {
     server.addTool({
         name: 'feedback',
         description:
-            'Submit feedback or a bug report for google-tools-mcp. Automatically collects diagnostic info and generates a pre-filled GitHub issue URL.',
+            'Submit feedback or a bug report for google-tools-mcp. Automatically collects diagnostic info, then files the issue via the GitHub CLI (`gh`) if available, or falls back to opening a pre-filled GitHub issue URL in the user\'s browser.',
         parameters: z.object({
             type: z.enum(['bug', 'feature']).describe('Type of feedback'),
             title: z.string().describe('Short summary'),
@@ -334,21 +423,38 @@ export async function registerAllTools(server) {
                 `</details>`,
             ].join('\n');
 
-            // Build GitHub issue URL
             const label = args.type === 'bug' ? 'bug' : 'enhancement';
+
+            // Try gh CLI first
+            const ghResult = await tryGhCli(args.title, body, label);
+            if (ghResult.ok) {
+                return JSON.stringify({
+                    method: 'gh-cli',
+                    issueUrl: ghResult.issueUrl,
+                    note: 'Issue filed successfully via GitHub CLI.',
+                }, null, 2);
+            }
+
+            // Fallback: open pre-filled GitHub issue URL in the user's browser
             const params = new URLSearchParams({
                 title: args.title,
                 body,
                 labels: label,
             });
-            const url = `https://github.com/karthikcsq/google-tools-mcp/issues/new?${params.toString()}`;
+            const url = `https://github.com/${REPO}/issues/new?${params.toString()}`;
+            const opened = await openBrowser(url);
 
             return JSON.stringify({
+                method: 'browser-fallback',
+                ghCliUnavailableReason: ghResult.reason,
                 url,
+                browserOpened: opened,
                 markdown: body,
                 note: url.length > 8000
-                    ? 'The URL may be too long for some browsers. Use the markdown body below to create the issue manually.'
-                    : 'Open the URL to create a pre-filled GitHub issue.',
+                    ? 'The URL may be too long for some browsers. Use the markdown body to create the issue manually.'
+                    : opened
+                        ? 'Opened the pre-filled GitHub issue in your browser. Click "Submit new issue" to file it.'
+                        : 'Could not auto-open browser. Please open the URL manually.',
             }, null, 2);
         },
     });

package/dist/tools/sheets/addConditionalFormatting.js

@@ -130,7 +130,8 @@ export function register(server) {
                     format.textFormat = textFormat;
                 }
                 await SheetsHelpers.addConditionalFormatRule(sheets, args.spreadsheetId, gridRanges, args.conditionType, conditionValues, format);
-                return `Successfully added conditional formatting rule to ${args.ranges.join(', ')}.`;
+                const sheetUrl = `https://docs.google.com/spreadsheets/d/${args.spreadsheetId}/edit`;
+                return `${sheetUrl}\nSuccessfully added conditional formatting rule to ${args.ranges.join(', ')}.`;
             }
             catch (error) {
                 log.error(`Error adding conditional format rule: ${error.message || error}`);

package/dist/tools/sheets/addSpreadsheetSheet.js

@@ -21,7 +21,8 @@ export function register(server) {
                 if (!addedSheet) {
                     throw new UserError('Failed to add sheet - no sheet properties returned.');
                 }
-                return `Successfully added sheet "${addedSheet.title}" (Sheet ID: ${addedSheet.sheetId}) to spreadsheet.`;
+                const sheetUrl = `https://docs.google.com/spreadsheets/d/${args.spreadsheetId}/edit`;
+                return `${sheetUrl}\nSuccessfully added sheet "${addedSheet.title}" (Sheet ID: ${addedSheet.sheetId}) to spreadsheet.`;
             }
             catch (error) {
                 log.error(`Error adding sheet to spreadsheet ${args.spreadsheetId}: ${error.message || error}`);

package/dist/tools/sheets/appendSpreadsheetRows.js

@@ -30,7 +30,8 @@ export function register(server) {
                 const updatedCells = response.updates?.updatedCells || 0;
                 const updatedRows = response.updates?.updatedRows || 0;
                 const updatedRange = response.updates?.updatedRange || args.range;
-                return `Successfully appended ${updatedRows} row(s) (${updatedCells} cells) to spreadsheet. Updated range: ${updatedRange}`;
+                const sheetUrl = `https://docs.google.com/spreadsheets/d/${args.spreadsheetId}/edit`;
+                return `${sheetUrl}\nSuccessfully appended ${updatedRows} row(s) (${updatedCells} cells) to spreadsheet. Updated range: ${updatedRange}`;
             }
             catch (error) {
                 log.error(`Error appending to spreadsheet ${args.spreadsheetId}: ${error.message || error}`);

package/dist/tools/sheets/appendTableRows.js

@@ -32,6 +32,7 @@ export function register(server) {
                 // Append rows to the table
                 const result = await SheetsHelpers.appendToTableHelper(sheets, args.spreadsheetId, table.tableId || '', args.values);
                 return JSON.stringify({
+                    url: `https://docs.google.com/spreadsheets/d/${args.spreadsheetId}/edit`,
                     tableId: table.tableId,
                     name: table.name,
                     rowsAppended: result.rowsAppended,

package/dist/tools/sheets/autoResizeColumns.js

@@ -54,7 +54,8 @@ export function register(server) {
                     },
                 });
                 const rangeDesc = args.columns ? `columns ${args.columns}` : 'all columns';
-                return `Successfully auto-resized ${rangeDesc} to fit content.`;
+                const sheetUrl = `https://docs.google.com/spreadsheets/d/${args.spreadsheetId}/edit`;
+                return `${sheetUrl}\nSuccessfully auto-resized ${rangeDesc} to fit content.`;
             }
             catch (error) {
                 log.error(`Error auto-resizing columns: ${error.message || error}`);

package/dist/tools/sheets/batchWrite.js

@@ -1,6 +1,7 @@
 import { UserError } from 'fastmcp';
 import { z } from 'zod';
 import { getSheetsClient } from '../../clients.js';
+import { guardMutation, trackMutation } from '../../readTracker.js';
 export function register(server) {
     server.addTool({
         name: 'batchWrite',
@@ -25,6 +26,7 @@ export function register(server) {
                 .describe('How input data should be interpreted. RAW: values are stored as-is. USER_ENTERED: values are parsed as if typed by a user.'),
         }),
         execute: async (args, { log }) => {
+            await guardMutation(args.spreadsheetId);
             const sheets = await getSheetsClient();
             const rangeNames = args.data.map((d) => d.range).join(', ');
             log.info(`Batch writing to ${args.data.length} range(s) in spreadsheet ${args.spreadsheetId}: ${rangeNames}`);
@@ -40,7 +42,8 @@ export function register(server) {
                 const totalRows = response.data.totalUpdatedRows || 0;
                 const totalColumns = response.data.totalUpdatedColumns || 0;
                 const totalSheets = response.data.totalUpdatedSheets || 0;
-                return `Successfully batch-wrote ${totalCells} cells (${totalRows} rows, ${totalColumns} columns) across ${totalSheets} sheet(s) in ${args.data.length} range(s).`;
+                const sheetUrl = `https://docs.google.com/spreadsheets/d/${args.spreadsheetId}/edit`;
+                return `${sheetUrl}\nSuccessfully batch-wrote ${totalCells} cells (${totalRows} rows, ${totalColumns} columns) across ${totalSheets} sheet(s) in ${args.data.length} range(s).`;
             }
             catch (error) {
                 log.error(`Error batch writing to spreadsheet ${args.spreadsheetId}: ${error.message || error}`);

package/dist/tools/sheets/clearSpreadsheetRange.js

@@ -2,6 +2,7 @@ import { UserError } from 'fastmcp';
 import { z } from 'zod';
 import { getSheetsClient } from '../../clients.js';
 import * as SheetsHelpers from '../../googleSheetsApiHelpers.js';
+import { guardMutation, trackMutation } from '../../readTracker.js';
 export function register(server) {
     server.addTool({
         name: 'clearRange',
@@ -13,12 +14,14 @@ export function register(server) {
             range: z.string().describe('A1 notation range to clear (e.g., "A1:B10" or "Sheet1!A1:B10").'),
         }),
         execute: async (args, { log }) => {
+            await guardMutation(args.spreadsheetId);
             const sheets = await getSheetsClient();
             log.info(`Clearing range ${args.range} in spreadsheet ${args.spreadsheetId}`);
             try {
                 const response = await SheetsHelpers.clearRange(sheets, args.spreadsheetId, args.range);
                 const clearedRange = response.clearedRange || args.range;
-                return `Successfully cleared range ${clearedRange}.`;
+                const sheetUrl = `https://docs.google.com/spreadsheets/d/${args.spreadsheetId}/edit`;
+                return `${sheetUrl}\nSuccessfully cleared range ${clearedRange}.`;
             }
             catch (error) {
                 log.error(`Error clearing range in spreadsheet ${args.spreadsheetId}: ${error.message || error}`);

package/dist/tools/sheets/copyFormatting.js

@@ -46,7 +46,8 @@ export function register(server) {
                         ],
                     },
                 });
-                return `Successfully copied formatting from ${args.sourceSheetName}!${args.sourceRange} to ${args.destinationSheetName}!${args.destinationRange}.`;
+                const sheetUrl = `https://docs.google.com/spreadsheets/d/${args.spreadsheetId}/edit`;
+                return `${sheetUrl}\nSuccessfully 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}`);

package/dist/tools/sheets/createTable.js

@@ -102,6 +102,7 @@ export function register(server) {
                     columnProperties,
                 });
                 return JSON.stringify({
+                    url: `https://docs.google.com/spreadsheets/d/${args.spreadsheetId}/edit`,
                     tableId: table.tableId,
                     name: table.name,
                     range: args.range,

package/dist/tools/sheets/deleteChart.js

@@ -28,7 +28,8 @@ export function register(server) {
                         ],
                     },
                 });
-                return `Chart ${args.chartId} deleted successfully.`;
+                const sheetUrl = `https://docs.google.com/spreadsheets/d/${args.spreadsheetId}/edit`;
+                return `${sheetUrl}\nChart ${args.chartId} deleted successfully.`;
             }
             catch (error) {
                 log.error(`Error deleting chart: ${error.message || error}`);

package/dist/tools/sheets/deleteSheet.js

@@ -30,7 +30,8 @@ export function register(server) {
                         ],
                     },
                 });
-                return `Successfully deleted sheet (ID: ${args.sheetId}) from spreadsheet.`;
+                const sheetUrl = `https://docs.google.com/spreadsheets/d/${args.spreadsheetId}/edit`;
+                return `${sheetUrl}\nSuccessfully deleted sheet (ID: ${args.sheetId}) from spreadsheet.`;
             }
             catch (error) {
                 log.error(`Error deleting sheet in spreadsheet ${args.spreadsheetId}: ${error.message || error}`);

package/dist/tools/sheets/deleteTable.js

@@ -35,6 +35,7 @@ export function register(server) {
                     clearedRange = range;
                 }
                 return JSON.stringify({
+                    url: `https://docs.google.com/spreadsheets/d/${args.spreadsheetId}/edit`,
                     tableId: table.tableId,
                     name: table.name,
                     deleted: true,

package/dist/tools/sheets/duplicateSheet.js

@@ -40,7 +40,8 @@ export function register(server) {
                 if (!duplicatedSheet) {
                     throw new UserError('Failed to duplicate sheet - no sheet properties returned.');
                 }
-                return `Successfully duplicated sheet as "${duplicatedSheet.title}" (Sheet ID: ${duplicatedSheet.sheetId}).`;
+                const sheetUrl = `https://docs.google.com/spreadsheets/d/${args.spreadsheetId}/edit`;
+                return `${sheetUrl}\nSuccessfully duplicated sheet as "${duplicatedSheet.title}" (Sheet ID: ${duplicatedSheet.sheetId}).`;
             }
             catch (error) {
                 log.error(`Error duplicating sheet in spreadsheet ${args.spreadsheetId}: ${error.message || error}`);

package/dist/tools/sheets/formatCells.js

@@ -93,7 +93,8 @@ export function register(server) {
                     format.numberFormat = args.numberFormat;
                 }
                 await SheetsHelpers.formatCells(sheets, args.spreadsheetId, args.range, format);
-                return `Successfully applied formatting to range "${args.range}".`;
+                const sheetUrl = `https://docs.google.com/spreadsheets/d/${args.spreadsheetId}/edit`;
+                return `${sheetUrl}\nSuccessfully applied formatting to range "${args.range}".`;
             }
             catch (error) {
                 log.error(`Error formatting cells: ${error.message || error}`);

package/dist/tools/sheets/freezeRowsAndColumns.js

@@ -45,7 +45,8 @@ export function register(server) {
                         ? 'unfroze columns'
                         : `froze left ${args.frozenColumns} column(s)`);
                 }
-                return `Successfully ${parts.join(' and ')}.`;
+                const sheetUrl = `https://docs.google.com/spreadsheets/d/${args.spreadsheetId}/edit`;
+                return `${sheetUrl}\nSuccessfully ${parts.join(' and ')}.`;
             }
             catch (error) {
                 log.error(`Error freezing rows/columns: ${error.message || error}`);

package/dist/tools/sheets/getSpreadsheetInfo.js

@@ -2,6 +2,7 @@ import { UserError } from 'fastmcp';
 import { z } from 'zod';
 import { getSheetsClient } from '../../clients.js';
 import * as SheetsHelpers from '../../googleSheetsApiHelpers.js';
+import { trackRead } from '../../readTracker.js';
 export function register(server) {
     server.addTool({
         name: 'getSpreadsheetInfo',
@@ -16,6 +17,7 @@ export function register(server) {
             log.info(`Getting info for spreadsheet: ${args.spreadsheetId}`);
             try {
                 const metadata = await SheetsHelpers.getSpreadsheetMetadata(sheets, args.spreadsheetId);
+                trackRead(args.spreadsheetId);
                 const sheetList = metadata.sheets || [];
                 return JSON.stringify({
                     title: metadata.properties?.title || 'Untitled',

package/dist/tools/sheets/groupRows.js

@@ -49,7 +49,8 @@ export function register(server) {
                     spreadsheetId: args.spreadsheetId,
                     requestBody: { requests },
                 });
-                return `Successfully created ${args.groups.length} row group(s).`;
+                const sheetUrl = `https://docs.google.com/spreadsheets/d/${args.spreadsheetId}/edit`;
+                return `${sheetUrl}\nSuccessfully created ${args.groups.length} row group(s).`;
             }
             catch (error) {
                 log.error(`Error grouping rows: ${error.message || error}`);