google-tools-mcp 1.0.4 → 1.0.6

package/dist/tools/drive/downloadFile.js

@@ -0,0 +1,268 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDriveClient } from '../../clients.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { Readable } from 'stream';
+import { pipeline } from 'stream/promises';
+import { createWriteStream } from 'fs';
+
+// Google Workspace MIME types and their export formats
+const EXPORT_FORMATS = {
+    'application/vnd.google-apps.document': {
+        label: 'Google Doc',
+        formats: {
+            pdf: 'application/pdf',
+            docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            md: 'text/markdown',
+            txt: 'text/plain',
+            html: 'text/html',
+            rtf: 'application/rtf',
+            odt: 'application/vnd.oasis.opendocument.text',
+            epub: 'application/epub+zip',
+        },
+        defaultFormat: 'pdf',
+        extensions: {
+            pdf: '.pdf',
+            docx: '.docx',
+            md: '.md',
+            txt: '.txt',
+            html: '.html',
+            rtf: '.rtf',
+            odt: '.odt',
+            epub: '.epub',
+        },
+    },
+    'application/vnd.google-apps.spreadsheet': {
+        label: 'Google Sheet',
+        formats: {
+            pdf: 'application/pdf',
+            xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            csv: 'text/csv',
+            tsv: 'text/tab-separated-values',
+            ods: 'application/vnd.oasis.opendocument.spreadsheet',
+        },
+        defaultFormat: 'xlsx',
+        extensions: {
+            pdf: '.pdf',
+            xlsx: '.xlsx',
+            csv: '.csv',
+            tsv: '.tsv',
+            ods: '.ods',
+        },
+    },
+    'application/vnd.google-apps.presentation': {
+        label: 'Google Slides',
+        formats: {
+            pdf: 'application/pdf',
+            pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+            odp: 'application/vnd.oasis.opendocument.presentation',
+            txt: 'text/plain',
+        },
+        defaultFormat: 'pdf',
+        extensions: {
+            pdf: '.pdf',
+            pptx: '.pptx',
+            odp: '.odp',
+            txt: '.txt',
+        },
+    },
+    'application/vnd.google-apps.drawing': {
+        label: 'Google Drawing',
+        formats: {
+            pdf: 'application/pdf',
+            png: 'image/png',
+            jpg: 'image/jpeg',
+            svg: 'image/svg+xml',
+        },
+        defaultFormat: 'pdf',
+        extensions: {
+            pdf: '.pdf',
+            png: '.png',
+            jpg: '.jpg',
+            svg: '.svg',
+        },
+    },
+};
+
+// All supported export format keys
+const ALL_FORMAT_KEYS = [
+    ...new Set(
+        Object.values(EXPORT_FORMATS).flatMap((t) => Object.keys(t.formats))
+    ),
+];
+
+export function register(server) {
+    server.addTool({
+        name: 'downloadFile',
+        description:
+            'Downloads a file from Google Drive to the local filesystem. ' +
+            'For Google Workspace files (Docs, Sheets, Slides, Drawings), specify an export format ' +
+            '(e.g. pdf, docx, md, xlsx, csv, pptx). For regular files (images, PDFs, etc.), ' +
+            'downloads the original file directly.',
+        parameters: z.object({
+            fileId: z.string().describe('The ID of the file to download.'),
+            localPath: z
+                .string()
+                .describe(
+                    'The local file path to save the downloaded file to. ' +
+                    'Can be an absolute path or relative to the current working directory. ' +
+                    'If a directory is provided, the file will be saved with its Drive name.'
+                ),
+            exportFormat: z
+                .enum(ALL_FORMAT_KEYS)
+                .optional()
+                .describe(
+                    'Export format for Google Workspace files. ' +
+                    'Docs: pdf, docx, md, txt, html, rtf, odt, epub. ' +
+                    'Sheets: pdf, xlsx, csv, tsv, ods. ' +
+                    'Slides: pdf, pptx, odp, txt. ' +
+                    'Drawings: pdf, png, jpg, svg. ' +
+                    'Ignored for non-Google files (they download as-is).'
+                ),
+        }),
+        execute: async (args, { log }) => {
+            const drive = await getDriveClient();
+            log.info(`Downloading file: ${args.fileId}`);
+
+            try {
+                // Get file metadata first
+                const metaResponse = await drive.files.get({
+                    fileId: args.fileId,
+                    fields: 'id,name,mimeType,size',
+                    supportsAllDrives: true,
+                });
+                const file = metaResponse.data;
+                if (!file) {
+                    throw new UserError(
+                        `File with ID ${args.fileId} not found.`
+                    );
+                }
+
+                const isGoogleWorkspace =
+                    file.mimeType in EXPORT_FORMATS;
+
+                // Determine export MIME type and file extension
+                let exportMimeType = null;
+                let fileExtension = '';
+
+                if (isGoogleWorkspace) {
+                    const typeInfo = EXPORT_FORMATS[file.mimeType];
+                    const format =
+                        args.exportFormat || typeInfo.defaultFormat;
+
+                    if (!typeInfo.formats[format]) {
+                        const available = Object.keys(
+                            typeInfo.formats
+                        ).join(', ');
+                        throw new UserError(
+                            `Format '${format}' is not supported for ${typeInfo.label}. ` +
+                            `Available formats: ${available}`
+                        );
+                    }
+
+                    exportMimeType = typeInfo.formats[format];
+                    fileExtension = typeInfo.extensions[format];
+                }
+
+                // Resolve the local path
+                let destPath = path.resolve(args.localPath);
+
+                // Check if destPath is a directory
+                let isDir = false;
+                try {
+                    const stat = await fs.stat(destPath);
+                    isDir = stat.isDirectory();
+                } catch {
+                    // Path doesn't exist yet — treat as a file path
+                }
+
+                if (isDir) {
+                    // Build filename from Drive name + appropriate extension
+                    let fileName = file.name;
+                    if (isGoogleWorkspace && fileExtension) {
+                        // Google Workspace files don't have extensions in their name
+                        fileName = file.name + fileExtension;
+                    }
+                    destPath = path.join(destPath, fileName);
+                } else if (
+                    isGoogleWorkspace &&
+                    fileExtension &&
+                    !destPath.endsWith(fileExtension)
+                ) {
+                    // Append extension if not already present
+                    destPath = destPath + fileExtension;
+                }
+
+                // Ensure parent directory exists
+                await fs.mkdir(path.dirname(destPath), { recursive: true });
+
+                // Download the file
+                if (isGoogleWorkspace) {
+                    log.info(
+                        `Exporting ${EXPORT_FORMATS[file.mimeType].label} as ${args.exportFormat || EXPORT_FORMATS[file.mimeType].defaultFormat}`
+                    );
+                    const exportResponse = await drive.files.export(
+                        { fileId: args.fileId, mimeType: exportMimeType },
+                        { responseType: 'stream' }
+                    );
+                    await pipeline(
+                        exportResponse.data,
+                        createWriteStream(destPath)
+                    );
+                } else {
+                    log.info(`Downloading binary file: ${file.name}`);
+                    const downloadResponse = await drive.files.get(
+                        {
+                            fileId: args.fileId,
+                            alt: 'media',
+                            supportsAllDrives: true,
+                        },
+                        { responseType: 'stream' }
+                    );
+                    await pipeline(
+                        downloadResponse.data,
+                        createWriteStream(destPath)
+                    );
+                }
+
+                // Get the final file size
+                const stat = await fs.stat(destPath);
+
+                const result = {
+                    success: true,
+                    fileName: file.name,
+                    savedTo: destPath,
+                    fileSize: stat.size,
+                    mimeType: isGoogleWorkspace
+                        ? exportMimeType
+                        : file.mimeType,
+                };
+
+                if (isGoogleWorkspace) {
+                    result.exportedAs =
+                        args.exportFormat ||
+                        EXPORT_FORMATS[file.mimeType].defaultFormat;
+                }
+
+                return JSON.stringify(result, null, 2);
+            } catch (error) {
+                if (error instanceof UserError) throw error;
+                log.error(
+                    `Error downloading file: ${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 download file: ${error.message || 'Unknown error'}`
+                );
+            }
+        },
+    });
+}

package/dist/tools/drive/index.js

@@ -12,6 +12,7 @@ import { register as createDocument } from './createDocument.js';
 import { register as createFromTemplate } from './createFromTemplate.js';
 import { register as listSharedDrives } from './listSharedDrives.js';
 import { register as listSharedWithMe } from './listSharedWithMe.js';
+import { register as downloadFile } from './downloadFile.js';
 export function registerDriveTools(server) {
     listDriveFiles(server);
     searchGoogleDocs(server);
@@ -27,4 +28,5 @@ export function registerDriveTools(server) {
     createFromTemplate(server);
     listSharedDrives(server);
     listSharedWithMe(server);
+    downloadFile(server);
 }

package/dist/tools/drive/listDriveFiles.js

@@ -56,8 +56,9 @@ export function register(server) {
                 // Filter by mime type
                 if (args.fileType !== 'all') {
                     queryParts.push(`mimeType='${MIME_TYPES[args.fileType]}'`);
-                } else {
-                    // Exclude folders from "all" results
+                } 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'");
                 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "google-tools-mcp",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "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/getDocumentInfo.js

@@ -1,48 +0,0 @@
-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'}`);
-            }
-        },
-    });
-}

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'}`);
-            }
-        },
-    });
-}