google-tools-mcp 1.0.3 → 1.0.5

package/dist/tools/docs/formatting/index.js

@@ -1,6 +1,4 @@
-import { register as applyTextStyle } from './applyTextStyle.js';
 import { register as applyParagraphStyle } from './applyParagraphStyle.js';
 export function registerFormattingTools(server) {
-    applyTextStyle(server);
     applyParagraphStyle(server);
 }

package/dist/tools/docs/index.js

@@ -4,7 +4,6 @@ import { register as listDocumentTabs } from './listDocumentTabs.js';
 import { register as renameTab } from './renameTab.js';
 import { register as addTab } from './addTab.js';
 import { register as appendToGoogleDoc } from './appendToGoogleDoc.js';
-import { register as insertText } from './insertText.js';
 import { register as deleteRange } from './deleteRange.js';
 import { register as modifyText } from './modifyText.js';
 import { register as findAndReplace } from './findAndReplace.js';
@@ -23,7 +22,6 @@ export function registerDocsTools(server) {
     renameTab(server);
     addTab(server);
     appendToGoogleDoc(server);
-    insertText(server);
     deleteRange(server);
     modifyText(server);
     findAndReplace(server);

package/dist/tools/drive/{getDocumentInfo.js → getFileInfo.js}

@@ -1,48 +1,48 @@
-import { UserError } from 'fastmcp';
-import { getDriveClient } from '../../clients.js';
-import { DocumentIdParameter } from '../../types.js';
-export function register(server) {
-    server.addTool({
-        name: 'getDocumentInfo',
-        description: 'Gets metadata about a document including its name, owner, sharing status, and modification history.',
-        parameters: DocumentIdParameter,
-        execute: async (args, { log }) => {
-            const drive = await getDriveClient();
-            log.info(`Getting info for document: ${args.documentId}`);
-            try {
-                const response = await drive.files.get({
-                    fileId: args.documentId,
-                    // Note: 'permissions' and 'alternateLink' fields removed - they cause
-                    // "Invalid field selection" errors for Google Docs files
-                    fields: 'id,name,description,mimeType,size,createdTime,modifiedTime,webViewLink,owners(displayName,emailAddress),lastModifyingUser(displayName,emailAddress),shared,parents,version',
-                    supportsAllDrives: true,
-                });
-                const file = response.data;
-                if (!file) {
-                    throw new UserError(`Document with ID ${args.documentId} not found.`);
-                }
-                const info = {
-                    id: file.id,
-                    name: file.name,
-                    mimeType: file.mimeType,
-                    createdTime: file.createdTime,
-                    modifiedTime: file.modifiedTime,
-                    owner: file.owners?.[0]?.displayName || null,
-                    lastModifyingUser: file.lastModifyingUser?.displayName || null,
-                    shared: file.shared || false,
-                    url: file.webViewLink,
-                    description: file.description || null,
-                };
-                return JSON.stringify(info, null, 2);
-            }
-            catch (error) {
-                log.error(`Error getting document info: ${error.message || error}`);
-                if (error.code === 404)
-                    throw new UserError(`Document not found (ID: ${args.documentId}).`);
-                if (error.code === 403)
-                    throw new UserError('Permission denied. Make sure you have access to this document.');
-                throw new UserError(`Failed to get document info: ${error.message || 'Unknown error'}`);
-            }
-        },
-    });
-}
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDriveClient } from '../../clients.js';
+export function register(server) {
+    server.addTool({
+        name: 'getFileInfo',
+        description: 'Gets metadata about any Drive file (document, spreadsheet, PDF, etc.) including its name, type, owner, sharing status, and modification history.',
+        parameters: z.object({
+            fileId: z.string().describe('The ID of the file to get information about.'),
+        }),
+        execute: async (args, { log }) => {
+            const drive = await getDriveClient();
+            log.info(`Getting info for file: ${args.fileId}`);
+            try {
+                const response = await drive.files.get({
+                    fileId: args.fileId,
+                    fields: 'id,name,description,mimeType,size,createdTime,modifiedTime,webViewLink,owners(displayName,emailAddress),lastModifyingUser(displayName,emailAddress),shared,parents,version',
+                    supportsAllDrives: true,
+                });
+                const file = response.data;
+                if (!file) {
+                    throw new UserError(`File with ID ${args.fileId} not found.`);
+                }
+                const info = {
+                    id: file.id,
+                    name: file.name,
+                    mimeType: file.mimeType,
+                    createdTime: file.createdTime,
+                    modifiedTime: file.modifiedTime,
+                    owner: file.owners?.[0]?.displayName || null,
+                    lastModifyingUser: file.lastModifyingUser?.displayName || null,
+                    shared: file.shared || false,
+                    url: file.webViewLink,
+                    description: file.description || null,
+                };
+                return JSON.stringify(info, null, 2);
+            }
+            catch (error) {
+                log.error(`Error getting file info: ${error.message || error}`);
+                if (error.code === 404)
+                    throw new UserError(`File not found (ID: ${args.fileId}).`);
+                if (error.code === 403)
+                    throw new UserError('Permission denied. Make sure you have access to this file.');
+                throw new UserError(`Failed to get file info: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/drive/index.js

@@ -1,6 +1,6 @@
-import { register as listGoogleDocs } from './listGoogleDocs.js';
+import { register as listDriveFiles } from './listDriveFiles.js';
 import { register as searchGoogleDocs } from './searchGoogleDocs.js';
-import { register as getDocumentInfo } from './getDocumentInfo.js';
+import { register as getFileInfo } from './getFileInfo.js';
 import { register as createFolder } from './createFolder.js';
 import { register as listFolderContents } from './listFolderContents.js';
 import { register as getFolderInfo } from './getFolderInfo.js';
@@ -13,9 +13,9 @@ import { register as createFromTemplate } from './createFromTemplate.js';
 import { register as listSharedDrives } from './listSharedDrives.js';
 import { register as listSharedWithMe } from './listSharedWithMe.js';
 export function registerDriveTools(server) {
-    listGoogleDocs(server);
+    listDriveFiles(server);
     searchGoogleDocs(server);
-    getDocumentInfo(server);
+    getFileInfo(server);
     createFolder(server);
     listFolderContents(server);
     getFolderInfo(server);

package/dist/tools/drive/listDriveFiles.js

@@ -0,0 +1,107 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDriveClient } from '../../clients.js';
+
+const MIME_TYPES = {
+    document: 'application/vnd.google-apps.document',
+    spreadsheet: 'application/vnd.google-apps.spreadsheet',
+    presentation: 'application/vnd.google-apps.presentation',
+    form: 'application/vnd.google-apps.form',
+    pdf: 'application/pdf',
+};
+
+export function register(server) {
+    server.addTool({
+        name: 'listDriveFiles',
+        description:
+            'Lists files in your Drive, optionally filtered by type (document, spreadsheet, presentation, form, pdf), name/content query, or modification date.',
+        parameters: z.object({
+            fileType: z
+                .enum(['document', 'spreadsheet', 'presentation', 'form', 'pdf', 'all'])
+                .optional()
+                .default('all')
+                .describe('Filter by file type. Defaults to all types.'),
+            maxResults: z
+                .number()
+                .int()
+                .min(1)
+                .max(100)
+                .optional()
+                .default(20)
+                .describe('Maximum number of files to return (1-100).'),
+            query: z
+                .string()
+                .optional()
+                .describe('Search query to filter files by name or content.'),
+            orderBy: z
+                .enum(['name', 'modifiedTime', 'createdTime'])
+                .optional()
+                .default('modifiedTime')
+                .describe('Sort order for results.'),
+            modifiedAfter: z
+                .string()
+                .optional()
+                .describe(
+                    'Only return files modified after this date (ISO 8601 format, e.g., "2024-01-01").'
+                ),
+        }),
+        execute: async (args, { log }) => {
+            const drive = await getDriveClient();
+            log.info(
+                `Listing Drive files. Type: ${args.fileType}, Query: ${args.query || 'none'}, Max: ${args.maxResults}, Order: ${args.orderBy}`
+            );
+            try {
+                let queryParts = ['trashed=false'];
+
+                // Filter by mime type
+                if (args.fileType !== 'all') {
+                    queryParts.push(`mimeType='${MIME_TYPES[args.fileType]}'`);
+                } else if (!args.query) {
+                    // Exclude folders from "all" results only when not doing fullText search
+                    // (Drive API doesn't allow fullText contains with negated mimeType filters)
+                    queryParts.push("mimeType!='application/vnd.google-apps.folder'");
+                }
+
+                if (args.query) {
+                    queryParts.push(
+                        `(name contains '${args.query}' or fullText contains '${args.query}')`
+                    );
+                }
+
+                if (args.modifiedAfter) {
+                    const cutoffDate = new Date(args.modifiedAfter).toISOString();
+                    queryParts.push(`modifiedTime > '${cutoffDate}'`);
+                }
+
+                const response = await drive.files.list({
+                    q: queryParts.join(' and '),
+                    pageSize: args.maxResults,
+                    orderBy: args.orderBy === 'name' ? 'name' : args.orderBy,
+                    fields: 'files(id,name,mimeType,modifiedTime,createdTime,size,webViewLink,owners(displayName,emailAddress))',
+                    supportsAllDrives: true,
+                    includeItemsFromAllDrives: true,
+                });
+
+                const files = (response.data.files || []).map((file) => ({
+                    id: file.id,
+                    name: file.name,
+                    mimeType: file.mimeType,
+                    modifiedTime: file.modifiedTime,
+                    owner: file.owners?.[0]?.displayName || null,
+                    url: file.webViewLink,
+                }));
+
+                return JSON.stringify({ files }, null, 2);
+            } catch (error) {
+                log.error(`Error listing Drive files: ${error.message || error}`);
+                if (error.code === 403)
+                    throw new UserError(
+                        'Permission denied. Make sure you have granted Google Drive access to the application.'
+                    );
+                throw new UserError(
+                    `Failed to list files: ${error.message || 'Unknown error'}`
+                );
+            }
+        },
+    });
+}

package/dist/tools/sheets/index.js

@@ -6,7 +6,6 @@ import { register as clearSpreadsheetRange } from './clearSpreadsheetRange.js';
 import { register as getSpreadsheetInfo } from './getSpreadsheetInfo.js';
 import { register as addSpreadsheetSheet } from './addSpreadsheetSheet.js';
 import { register as createSpreadsheet } from './createSpreadsheet.js';
-import { register as listGoogleSheets } from './listGoogleSheets.js';
 import { register as deleteSheet } from './deleteSheet.js';
 import { register as renameSheet } from './renameSheet.js';
 import { register as duplicateSheet } from './duplicateSheet.js';
@@ -39,7 +38,6 @@ export function registerSheetsTools(server) {
     getSpreadsheetInfo(server);
     addSpreadsheetSheet(server);
     createSpreadsheet(server);
-    listGoogleSheets(server);
     deleteSheet(server);
     renameSheet(server);
     duplicateSheet(server);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "google-tools-mcp",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Combined Google Workspace MCP server (Drive, Docs, Sheets, Gmail) with lazy-loaded tool categories",
   "type": "module",
   "bin": {

package/dist/tools/docs/formatting/applyTextStyle.js

@@ -1,49 +0,0 @@
-import { UserError } from 'fastmcp';
-import { getDocsClient } from '../../../clients.js';
-import { ApplyTextStyleToolParameters, NotImplementedError, } from '../../../types.js';
-import * as GDocsHelpers from '../../../googleDocsApiHelpers.js';
-export function register(server) {
-    server.addTool({
-        name: 'applyTextStyle',
-        description: 'Applies character-level formatting (bold, italic, color, font, etc.) to text identified by a character range or by searching for a text string. This is the primary tool for styling text in a document.',
-        parameters: ApplyTextStyleToolParameters,
-        execute: async (args, { log }) => {
-            const docs = await getDocsClient();
-            let { startIndex, endIndex } = args.target; // Will be updated if target is text
-            log.info(`Applying text style in doc ${args.documentId}${args.tabId ? ` (tab: ${args.tabId})` : ''}. Target: ${JSON.stringify(args.target)}, Style: ${JSON.stringify(args.style)}`);
-            try {
-                // Determine target range
-                if ('textToFind' in args.target) {
-                    const range = await GDocsHelpers.findTextRange(docs, args.documentId, args.target.textToFind, args.target.matchInstance, args.tabId);
-                    if (!range) {
-                        throw new UserError(`Could not find instance ${args.target.matchInstance} of text "${args.target.textToFind}"${args.tabId ? ` in tab ${args.tabId}` : ''}.`);
-                    }
-                    startIndex = range.startIndex;
-                    endIndex = range.endIndex;
-                    log.info(`Found text "${args.target.textToFind}" (instance ${args.target.matchInstance}) at range ${startIndex}-${endIndex}`);
-                }
-                if (startIndex === undefined || endIndex === undefined) {
-                    throw new UserError('Target range could not be determined.');
-                }
-                if (endIndex <= startIndex) {
-                    throw new UserError('End index must be greater than start index for styling.');
-                }
-                // Build the request
-                const requestInfo = GDocsHelpers.buildUpdateTextStyleRequest(startIndex, endIndex, args.style, args.tabId);
-                if (!requestInfo) {
-                    return 'No valid text styling options were provided.';
-                }
-                await GDocsHelpers.executeBatchUpdate(docs, args.documentId, [requestInfo.request]);
-                return `Successfully applied text style (${requestInfo.fields.join(', ')}) to range ${startIndex}-${endIndex}${args.tabId ? ` in tab ${args.tabId}` : ''}.`;
-            }
-            catch (error) {
-                log.error(`Error applying text style in doc ${args.documentId}: ${error.message || error}`);
-                if (error instanceof UserError)
-                    throw error;
-                if (error instanceof NotImplementedError)
-                    throw error; // Should not happen here
-                throw new UserError(`Failed to apply text style: ${error.message || 'Unknown error'}`);
-            }
-        },
-    });
-}

package/dist/tools/docs/insertText.js

@@ -1,61 +0,0 @@
-import { UserError } from 'fastmcp';
-import { z } from 'zod';
-import { getDocsClient } from '../../clients.js';
-import { DocumentIdParameter } from '../../types.js';
-import * as GDocsHelpers from '../../googleDocsApiHelpers.js';
-export function register(server) {
-    server.addTool({
-        name: 'insertText',
-        description: "Inserts text at a specific character index within a document. Use readDocument with format='json' to determine the correct index.",
-        parameters: DocumentIdParameter.extend({
-            text: z.string().min(1).describe('The text to insert.'),
-            index: z
-                .number()
-                .int()
-                .min(1)
-                .describe("1-based character index within the document body. Use readDocument with format='json' to inspect indices."),
-            tabId: z
-                .string()
-                .optional()
-                .describe('The ID of the specific tab to insert into. If not specified, inserts into the first tab (or legacy document.body for documents without tabs).'),
-        }),
-        execute: async (args, { log }) => {
-            const docs = await getDocsClient();
-            log.info(`Inserting text in doc ${args.documentId} at index ${args.index}${args.tabId ? ` (tab: ${args.tabId})` : ''}`);
-            try {
-                if (args.tabId) {
-                    // For tab-specific inserts, we need to verify the tab exists first
-                    const docInfo = await docs.documents.get({
-                        documentId: args.documentId,
-                        includeTabsContent: true,
-                        fields: 'tabs(tabProperties,documentTab)',
-                    });
-                    const targetTab = GDocsHelpers.findTabById(docInfo.data, args.tabId);
-                    if (!targetTab) {
-                        throw new UserError(`Tab with ID "${args.tabId}" not found in document.`);
-                    }
-                    if (!targetTab.documentTab) {
-                        throw new UserError(`Tab "${args.tabId}" does not have content (may not be a document tab).`);
-                    }
-                    // Insert with tabId
-                    const location = { index: args.index, tabId: args.tabId };
-                    const request = {
-                        insertText: { location, text: args.text },
-                    };
-                    await GDocsHelpers.executeBatchUpdate(docs, args.documentId, [request]);
-                }
-                else {
-                    // Use existing helper for backward compatibility
-                    await GDocsHelpers.insertText(docs, args.documentId, args.text, args.index);
-                }
-                return `Successfully inserted text at index ${args.index}${args.tabId ? ` in tab ${args.tabId}` : ''}.`;
-            }
-            catch (error) {
-                log.error(`Error inserting text in doc ${args.documentId}: ${error.message || error}`);
-                if (error instanceof UserError)
-                    throw error;
-                throw new UserError(`Failed to insert text: ${error.message || 'Unknown error'}`);
-            }
-        },
-    });
-}

package/dist/tools/drive/listGoogleDocs.js

@@ -1,67 +0,0 @@
-import { UserError } from 'fastmcp';
-import { z } from 'zod';
-import { getDriveClient } from '../../clients.js';
-export function register(server) {
-    server.addTool({
-        name: 'listDocuments',
-        description: 'Lists Google Documents in your Drive, optionally filtered by name or content. Use modifiedAfter to find recently changed documents.',
-        parameters: z.object({
-            maxResults: z
-                .number()
-                .int()
-                .min(1)
-                .max(100)
-                .optional()
-                .default(20)
-                .describe('Maximum number of documents to return (1-100).'),
-            query: z.string().optional().describe('Search query to filter documents by name or content.'),
-            orderBy: z
-                .enum(['name', 'modifiedTime', 'createdTime'])
-                .optional()
-                .default('modifiedTime')
-                .describe('Sort order for results.'),
-            modifiedAfter: z
-                .string()
-                .optional()
-                .describe('Only return documents modified after this date (ISO 8601 format, e.g., "2024-01-01").'),
-        }),
-        execute: async (args, { log }) => {
-            const drive = await getDriveClient();
-            log.info(`Listing Google Docs. Query: ${args.query || 'none'}, Max: ${args.maxResults}, Order: ${args.orderBy}`);
-            try {
-                // Build the query string for Google Drive API
-                let queryString = "mimeType='application/vnd.google-apps.document' and trashed=false";
-                if (args.query) {
-                    queryString += ` and (name contains '${args.query}' or fullText contains '${args.query}')`;
-                }
-                if (args.modifiedAfter) {
-                    const cutoffDate = new Date(args.modifiedAfter).toISOString();
-                    queryString += ` and modifiedTime > '${cutoffDate}'`;
-                }
-                const response = await drive.files.list({
-                    q: queryString,
-                    pageSize: args.maxResults,
-                    orderBy: args.orderBy === 'name' ? 'name' : args.orderBy,
-                    fields: 'files(id,name,modifiedTime,createdTime,size,webViewLink,owners(displayName,emailAddress))',
-                    supportsAllDrives: true,
-                    includeItemsFromAllDrives: true,
-                });
-                const files = response.data.files || [];
-                const documents = files.map((file) => ({
-                    id: file.id,
-                    name: file.name,
-                    modifiedTime: file.modifiedTime,
-                    owner: file.owners?.[0]?.displayName || null,
-                    url: file.webViewLink,
-                }));
-                return JSON.stringify({ documents }, null, 2);
-            }
-            catch (error) {
-                log.error(`Error listing Google Docs: ${error.message || error}`);
-                if (error.code === 403)
-                    throw new UserError('Permission denied. Make sure you have granted Google Drive access to the application.');
-                throw new UserError(`Failed to list documents: ${error.message || 'Unknown error'}`);
-            }
-        },
-    });
-}

package/dist/tools/sheets/listGoogleSheets.js

@@ -1,62 +0,0 @@
-import { UserError } from 'fastmcp';
-import { z } from 'zod';
-import { getDriveClient } from '../../clients.js';
-export function register(server) {
-    server.addTool({
-        name: 'listSpreadsheets',
-        description: 'Lists spreadsheets in your Drive, optionally filtered by name or content.',
-        parameters: z.object({
-            maxResults: z
-                .number()
-                .int()
-                .min(1)
-                .max(100)
-                .optional()
-                .default(20)
-                .describe('Maximum number of spreadsheets to return (1-100).'),
-            query: z
-                .string()
-                .optional()
-                .describe('Search query to filter spreadsheets by name or content.'),
-            orderBy: z
-                .enum(['name', 'modifiedTime', 'createdTime'])
-                .optional()
-                .default('modifiedTime')
-                .describe('Sort order for results.'),
-        }),
-        execute: async (args, { log }) => {
-            const drive = await getDriveClient();
-            log.info(`Listing Google Sheets. Query: ${args.query || 'none'}, Max: ${args.maxResults}, Order: ${args.orderBy}`);
-            try {
-                // Build the query string for Google Drive API
-                let queryString = "mimeType='application/vnd.google-apps.spreadsheet' and trashed=false";
-                if (args.query) {
-                    queryString += ` and (name contains '${args.query}' or fullText contains '${args.query}')`;
-                }
-                const response = await drive.files.list({
-                    q: queryString,
-                    pageSize: args.maxResults,
-                    orderBy: args.orderBy === 'name' ? 'name' : args.orderBy,
-                    fields: 'files(id,name,modifiedTime,createdTime,size,webViewLink,owners(displayName,emailAddress))',
-                    supportsAllDrives: true,
-                    includeItemsFromAllDrives: true,
-                });
-                const files = response.data.files || [];
-                const spreadsheets = files.map((file) => ({
-                    id: file.id,
-                    name: file.name,
-                    modifiedTime: file.modifiedTime,
-                    owner: file.owners?.[0]?.displayName || null,
-                    url: file.webViewLink,
-                }));
-                return JSON.stringify({ spreadsheets }, null, 2);
-            }
-            catch (error) {
-                log.error(`Error listing Google Sheets: ${error.message || error}`);
-                if (error.code === 403)
-                    throw new UserError('Permission denied. Make sure you have granted Google Drive access to the application.');
-                throw new UserError(`Failed to list spreadsheets: ${error.message || 'Unknown error'}`);
-            }
-        },
-    });
-}