@triffon/google-docs-mcp 1.11.3-triffon

package/dist/tools/drive/downloadFile.js

@@ -0,0 +1,266 @@
+import { UserError, imageContent } from 'fastmcp';
+import { z } from 'zod';
+import fs from 'node:fs';
+import path from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { getDriveClient } from '../../clients.js';
+import { requestClients } from '../../remoteWrapper.js';
+import { createDownloadToken } from '../../downloadProxy.js';
+import { ensureWithinDownloadRoots, parseDownloadRoots } from './savePathGuard.js';
+const isRemote = process.env.MCP_TRANSPORT === 'httpStream';
+export const WORKSPACE_EXPORT_DEFAULTS = {
+    'application/vnd.google-apps.document': 'text/markdown',
+    'application/vnd.google-apps.spreadsheet': 'text/csv',
+    'application/vnd.google-apps.presentation': 'text/plain',
+    'application/vnd.google-apps.drawing': 'image/png',
+    'application/vnd.google-apps.script': 'application/vnd.google-apps.script+json',
+};
+export const EXPORT_MIME_TO_EXTENSION = {
+    'text/markdown': '.md',
+    'text/plain': '.txt',
+    'text/csv': '.csv',
+    'text/tab-separated-values': '.tsv',
+    'application/pdf': '.pdf',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document': '.docx',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': '.xlsx',
+    'application/vnd.openxmlformats-officedocument.presentationml.presentation': '.pptx',
+    'image/png': '.png',
+    'image/jpeg': '.jpg',
+    'application/vnd.google-apps.script+json': '.json',
+};
+const MAX_TEXT_EXTRACT_BYTES = 50_000;
+export function isTextMimeType(mime) {
+    return (mime.startsWith('text/') ||
+        mime === 'application/json' ||
+        mime === 'application/vnd.google-apps.script+json');
+}
+function isWorkspaceMimeType(mime) {
+    return mime.startsWith('application/vnd.google-apps.');
+}
+const DownloadFileParameters = z.strictObject({
+    fileId: z.string().describe('The file ID from a Google Drive URL or previous tool result.'),
+    savePath: z
+        .string()
+        .optional()
+        .describe('Local file path to save the downloaded file to. Parent directories are created automatically. ' +
+        "If omitted, saves to the current working directory using the file's original name " +
+        '(with an appropriate extension for exported Google Workspace files).'),
+    exportMimeType: z
+        .string()
+        .optional()
+        .describe('For Google Workspace files only: the MIME type to export as. ' +
+        'E.g. "text/markdown", "application/pdf", "text/csv". ' +
+        'Defaults: Docs->text/markdown, Sheets->text/csv, Slides->text/plain, Drawings->image/png.'),
+    extractText: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('If true, return text content in the response (up to 50KB) alongside saving the file. ' +
+        'Works for text/*, application/json. For binary files, only the save path is returned.'),
+    returnAs: z
+        .enum(['url', 'content'])
+        .optional()
+        .default('url')
+        .describe('Remote mode only. ' +
+        '"url" (default): returns a short-lived download URL -- use curl -o to save to disk. ' +
+        '"content": returns file content inline (text, image, or base64 resource).'),
+});
+export function register(server) {
+    server.addTool({
+        name: 'downloadFile',
+        description: 'Downloads any file from Google Drive to a local path. ' +
+            'For Google Workspace files (Docs, Sheets, Slides), exports to a specified format ' +
+            '(defaults to text/markdown for Docs, text/csv for Sheets). ' +
+            'For regular files (PDFs, images, etc.), downloads the raw bytes. ' +
+            'Optionally extracts and returns text content for text-based files.',
+        parameters: DownloadFileParameters,
+        execute: async (args, { log }) => {
+            const drive = await getDriveClient();
+            log.info(`Downloading file ${args.fileId}${args.savePath ? ` to ${args.savePath}` : ''}`);
+            let resolvedSavePath;
+            try {
+                // 1. Get file metadata
+                const metadataRes = await drive.files.get({
+                    fileId: args.fileId,
+                    fields: 'name,mimeType,size',
+                    supportsAllDrives: true,
+                });
+                const fileName = path.basename(metadataRes.data.name || 'download');
+                const originalMimeType = metadataRes.data.mimeType || 'application/octet-stream';
+                const isWorkspace = isWorkspaceMimeType(originalMimeType);
+                // 2. Resolve export MIME type for Workspace files
+                let exportMime;
+                if (isWorkspace) {
+                    exportMime = args.exportMimeType || WORKSPACE_EXPORT_DEFAULTS[originalMimeType];
+                    if (!exportMime) {
+                        const shortType = originalMimeType.replace('application/vnd.google-apps.', '');
+                        throw new UserError(`Unsupported Google Workspace type "${shortType}". ` +
+                            `Provide an exportMimeType parameter to specify the desired export format.`);
+                    }
+                }
+                // ---------- Remote mode ----------
+                if (isRemote) {
+                    const resolvedFileName = isWorkspace && exportMime
+                        ? path.parse(fileName).name + (EXPORT_MIME_TO_EXTENSION[exportMime] || '')
+                        : fileName;
+                    const outputMime = exportMime || originalMimeType;
+                    // --- returnAs: "url" (default) -- agent uses curl to save to disk ---
+                    if (args.returnAs !== 'content') {
+                        const store = requestClients.getStore();
+                        if (!store)
+                            throw new UserError('Request context missing.');
+                        const token = createDownloadToken({
+                            fileId: args.fileId,
+                            accessToken: store.accessToken,
+                            exportMime,
+                            fileName: resolvedFileName,
+                            mimeType: outputMime,
+                            isWorkspace,
+                        });
+                        const result = {
+                            downloadUrl: `${process.env.BASE_URL}/download/${token}`,
+                            fileName: resolvedFileName,
+                            originalMimeType,
+                        };
+                        if (isWorkspace && exportMime)
+                            result.exportedAs = exportMime;
+                        if (args.extractText !== false && isTextMimeType(outputMime)) {
+                            try {
+                                const textRes = isWorkspace && exportMime
+                                    ? await drive.files.export({ fileId: args.fileId, mimeType: exportMime }, { responseType: 'text' })
+                                    : await drive.files.get({ fileId: args.fileId, alt: 'media', supportsAllDrives: true }, { responseType: 'text' });
+                                result.textContent = textRes.data.slice(0, MAX_TEXT_EXTRACT_BYTES);
+                            }
+                            catch {
+                                log.warn?.('Could not extract text content');
+                            }
+                        }
+                        return JSON.stringify(result, null, 2);
+                    }
+                    // --- returnAs: "content" -- inline via MCP content types ---
+                    let fileBuffer;
+                    if (isWorkspace && exportMime) {
+                        log.info(`Exporting Workspace file as ${exportMime}`);
+                        const res = await drive.files.export({ fileId: args.fileId, mimeType: exportMime }, { responseType: 'arraybuffer' });
+                        fileBuffer = Buffer.from(res.data);
+                    }
+                    else {
+                        log.info('Downloading blob file into memory');
+                        const res = await drive.files.get({ fileId: args.fileId, alt: 'media', supportsAllDrives: true }, { responseType: 'arraybuffer' });
+                        fileBuffer = Buffer.from(res.data);
+                    }
+                    const MAX_INLINE_BYTES = 100 * 1024 * 1024;
+                    const content = [];
+                    if (isTextMimeType(outputMime)) {
+                        content.push({
+                            type: 'text',
+                            text: fileBuffer.toString('utf-8').slice(0, MAX_TEXT_EXTRACT_BYTES),
+                        });
+                    }
+                    else if (outputMime.startsWith('image/') && fileBuffer.length <= MAX_INLINE_BYTES) {
+                        content.push(await imageContent({ buffer: fileBuffer }));
+                    }
+                    else if (fileBuffer.length <= MAX_INLINE_BYTES) {
+                        content.push({
+                            type: 'resource',
+                            resource: {
+                                uri: `gdrive:///${args.fileId}/${resolvedFileName}`,
+                                blob: fileBuffer.toString('base64'),
+                                mimeType: outputMime,
+                            },
+                        });
+                    }
+                    else {
+                        throw new UserError(`File too large for inline transfer (${(fileBuffer.length / 1024 / 1024).toFixed(1)}MB, limit 100MB).`);
+                    }
+                    content.push({
+                        type: 'text',
+                        text: JSON.stringify({
+                            fileName: resolvedFileName,
+                            originalMimeType,
+                            sizeBytes: fileBuffer.length,
+                        }),
+                    });
+                    return { content };
+                }
+                // ---------- Stdio mode: write to local disk ----------
+                resolvedSavePath = args.savePath;
+                if (resolvedSavePath)
+                    resolvedSavePath = path.resolve(resolvedSavePath);
+                if (!resolvedSavePath) {
+                    if (isWorkspace && exportMime) {
+                        const baseName = path.parse(fileName).name;
+                        const ext = EXPORT_MIME_TO_EXTENSION[exportMime] || '';
+                        resolvedSavePath = path.join(process.cwd(), baseName + ext);
+                    }
+                    else {
+                        resolvedSavePath = path.join(process.cwd(), fileName);
+                    }
+                }
+                resolvedSavePath = path.resolve(resolvedSavePath);
+                // `savePath` is agent-controlled and reaches the filesystem directly, so
+                // confine it before creating directories or opening a write stream.
+                try {
+                    resolvedSavePath = ensureWithinDownloadRoots(resolvedSavePath, parseDownloadRoots());
+                }
+                catch (boundaryError) {
+                    throw new UserError(boundaryError?.message || String(boundaryError));
+                }
+                fs.mkdirSync(path.dirname(resolvedSavePath), { recursive: true });
+                let outputMime;
+                if (isWorkspace && exportMime) {
+                    log.info(`Exporting Workspace file as ${exportMime}`);
+                    const res = await drive.files.export({ fileId: args.fileId, mimeType: exportMime }, { responseType: 'stream' });
+                    await pipeline(res.data, fs.createWriteStream(resolvedSavePath));
+                    outputMime = exportMime;
+                }
+                else {
+                    log.info(`Downloading blob file`);
+                    const res = await drive.files.get({ fileId: args.fileId, alt: 'media', supportsAllDrives: true }, { responseType: 'stream' });
+                    await pipeline(res.data, fs.createWriteStream(resolvedSavePath));
+                    outputMime = originalMimeType;
+                }
+                const sizeBytes = fs.statSync(resolvedSavePath).size;
+                let textContent;
+                if (args.extractText !== false && isTextMimeType(outputMime)) {
+                    try {
+                        const raw = fs.readFileSync(resolvedSavePath, 'utf-8');
+                        textContent = raw.slice(0, MAX_TEXT_EXTRACT_BYTES);
+                    }
+                    catch {
+                        log.warn?.(`Could not read text from ${resolvedSavePath}`);
+                    }
+                }
+                const result = {
+                    savedTo: resolvedSavePath,
+                    fileName,
+                    originalMimeType,
+                    sizeBytes,
+                };
+                if (isWorkspace && exportMime)
+                    result.exportedAs = exportMime;
+                if (textContent !== undefined)
+                    result.textContent = textContent;
+                return JSON.stringify(result, null, 2);
+            }
+            catch (error) {
+                if (!isRemote && resolvedSavePath) {
+                    try {
+                        fs.unlinkSync(resolvedSavePath);
+                    }
+                    catch {
+                        /* file may not exist yet */
+                    }
+                }
+                log.error(`Error downloading file ${args.fileId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                if (error.code === 404)
+                    throw new UserError(`File not found (ID: ${args.fileId}). Check the file ID.`);
+                if (error.code === 403)
+                    throw new UserError(`Permission denied for file ${args.fileId}. Ensure the authenticated user has access.`);
+                throw new UserError(`Failed to download file: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/drive/getDocumentInfo.js

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

package/dist/tools/drive/getFolderInfo.js

@@ -0,0 +1,48 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDriveClient } from '../../clients.js';
+export function register(server) {
+    server.addTool({
+        name: 'getFolderInfo',
+        description: 'Gets metadata about a Drive folder including its name, owner, sharing status, and parent folder.',
+        parameters: z.strictObject({
+            folderId: z.string().describe('ID of the folder to get information about.'),
+        }),
+        execute: async (args, { log }) => {
+            const drive = await getDriveClient();
+            log.info(`Getting folder info: ${args.folderId}`);
+            try {
+                const response = await drive.files.get({
+                    fileId: args.folderId,
+                    fields: 'id,name,description,createdTime,modifiedTime,webViewLink,owners(displayName,emailAddress),lastModifyingUser(displayName),shared,parents',
+                    supportsAllDrives: true,
+                });
+                const file = response.data;
+                if (file.mimeType !== 'application/vnd.google-apps.folder') {
+                    throw new UserError('The specified ID does not belong to a folder.');
+                }
+                const info = {
+                    id: file.id,
+                    name: file.name,
+                    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,
+                    parentFolderId: file.parents?.[0] || null,
+                };
+                return JSON.stringify(info, null, 2);
+            }
+            catch (error) {
+                log.error(`Error getting folder info: ${error.message || error}`);
+                if (error.code === 404)
+                    throw new UserError(`Folder not found (ID: ${args.folderId}).`);
+                if (error.code === 403)
+                    throw new UserError('Permission denied. Make sure you have access to this folder.');
+                throw new UserError(`Failed to get folder info: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/drive/index.js

@@ -0,0 +1,34 @@
+import { register as listGoogleDocs } from './listGoogleDocs.js';
+import { register as searchGoogleDocs } from './searchGoogleDocs.js';
+import { register as listDriveFiles } from './listDriveFiles.js';
+import { register as searchDriveFiles } from './searchDriveFiles.js';
+import { register as getDocumentInfo } from './getDocumentInfo.js';
+import { register as createFolder } from './createFolder.js';
+import { register as listFolderContents } from './listFolderContents.js';
+import { register as getFolderInfo } from './getFolderInfo.js';
+import { register as moveFile } from './moveFile.js';
+import { register as copyFile } from './copyFile.js';
+import { register as renameFile } from './renameFile.js';
+import { register as deleteFile } from './deleteFile.js';
+import { register as createDocument } from './createDocument.js';
+import { register as createFromTemplate } from './createFromTemplate.js';
+import { register as downloadFile } from './downloadFile.js';
+import { register as setFilePermission } from './setFilePermission.js';
+export function registerDriveTools(server) {
+    listGoogleDocs(server);
+    searchGoogleDocs(server);
+    listDriveFiles(server);
+    searchDriveFiles(server);
+    getDocumentInfo(server);
+    createFolder(server);
+    listFolderContents(server);
+    getFolderInfo(server);
+    moveFile(server);
+    copyFile(server);
+    renameFile(server);
+    deleteFile(server);
+    createDocument(server);
+    createFromTemplate(server);
+    downloadFile(server);
+    setFilePermission(server);
+}

package/dist/tools/drive/listDriveFiles.js

@@ -0,0 +1,129 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDriveClient } from '../../clients.js';
+import { escapeDriveQuery } from '../../driveQueryUtils.js';
+/**
+ * Convenience shortcuts for common MIME types.
+ * Users can also pass any full MIME type string directly.
+ */
+const MIME_TYPE_SHORTCUTS = {
+    document: 'application/vnd.google-apps.document',
+    spreadsheet: 'application/vnd.google-apps.spreadsheet',
+    presentation: 'application/vnd.google-apps.presentation',
+    folder: 'application/vnd.google-apps.folder',
+    form: 'application/vnd.google-apps.form',
+    pdf: 'application/pdf',
+    zip: 'application/zip',
+};
+export function register(server) {
+    server.addTool({
+        name: 'listDriveFiles',
+        description: 'Lists files across Google Drive with optional filtering by type, folder, and ownership. ' +
+            'Unlike listDocuments (which only returns Google Docs), this tool works with all file types ' +
+            '(Sheets, PDFs, images, folders, etc.) and supports sort direction and size-based ordering. ' +
+            'Use mimeType shortcuts: "document", "spreadsheet", "presentation", "folder", "form", "pdf", "zip" ' +
+            'or pass any full MIME type string.',
+        parameters: z.strictObject({
+            maxResults: z
+                .number()
+                .int()
+                .min(1)
+                .max(100)
+                .optional()
+                .default(20)
+                .describe('Maximum number of files to return (1-100).'),
+            mimeType: z
+                .string()
+                .optional()
+                .describe('Filter by file type. Shortcuts: "document", "spreadsheet", "presentation", ' +
+                '"folder", "form", "pdf", "zip". Or pass a full MIME type (e.g. "image/png").'),
+            folderId: z
+                .string()
+                .optional()
+                .describe('Only return files directly inside this folder. Use "root" for the top-level Drive. ' +
+                'Omit to search across all folders.'),
+            orderBy: z
+                .enum(['name', 'modifiedTime', 'createdTime', 'quotaBytesUsed'])
+                .optional()
+                .default('modifiedTime')
+                .describe('Field to sort results by. "quotaBytesUsed" sorts by file size (note: Google-native files report 0).'),
+            sortDirection: z
+                .enum(['asc', 'desc'])
+                .optional()
+                .default('desc')
+                .describe('Sort direction: "asc" for oldest/smallest first, "desc" for newest/largest first.'),
+            ownedByMe: z
+                .boolean()
+                .optional()
+                .describe('If true, only return files owned by the authenticated user.'),
+            sharedWithMe: z
+                .boolean()
+                .optional()
+                .describe('If true, only return files shared with the authenticated user (excludes files they own). ' +
+                'Cannot be combined with ownedByMe.'),
+            modifiedAfter: z
+                .string()
+                .optional()
+                .describe('Only return files modified after this date (ISO 8601 format, e.g. "2024-01-01").'),
+        }),
+        execute: async (args, { log }) => {
+            if (args.ownedByMe && args.sharedWithMe) {
+                throw new UserError('ownedByMe and sharedWithMe cannot both be true.');
+            }
+            const drive = await getDriveClient();
+            log.info(`Listing Drive files. mimeType=${args.mimeType || 'any'}, folder=${args.folderId || 'all'}, ` +
+                `orderBy=${args.orderBy} ${args.sortDirection}, ownedByMe=${args.ownedByMe}, sharedWithMe=${args.sharedWithMe}`);
+            try {
+                const conditions = ['trashed=false'];
+                // Resolve MIME type shortcut or use value as-is
+                if (args.mimeType) {
+                    const resolved = MIME_TYPE_SHORTCUTS[args.mimeType] ?? args.mimeType;
+                    conditions.push(`mimeType='${escapeDriveQuery(resolved)}'`);
+                }
+                // Scope to a specific folder
+                if (args.folderId) {
+                    conditions.push(`'${escapeDriveQuery(args.folderId)}' in parents`);
+                }
+                // Ownership filter
+                if (args.ownedByMe) {
+                    conditions.push(`'me' in owners`);
+                }
+                else if (args.sharedWithMe) {
+                    conditions.push(`sharedWithMe=true`);
+                }
+                // Date filter
+                if (args.modifiedAfter) {
+                    const cutoff = new Date(args.modifiedAfter).toISOString();
+                    conditions.push(`modifiedTime > '${escapeDriveQuery(cutoff)}'`);
+                }
+                const queryString = conditions.join(' and ');
+                const orderByParam = args.sortDirection === 'desc' ? `${args.orderBy} desc` : args.orderBy;
+                const response = await drive.files.list({
+                    q: queryString,
+                    pageSize: args.maxResults,
+                    orderBy: orderByParam,
+                    fields: 'files(id,name,mimeType,size,modifiedTime,createdTime,webViewLink,owners(displayName,emailAddress))',
+                    supportsAllDrives: true,
+                    includeItemsFromAllDrives: true,
+                });
+                const files = (response.data.files || []).map((file) => ({
+                    id: file.id,
+                    name: file.name,
+                    mimeType: file.mimeType,
+                    size: file.size != null ? Number(file.size) : null,
+                    modifiedTime: file.modifiedTime,
+                    createdTime: file.createdTime,
+                    owner: file.owners?.[0]?.displayName || null,
+                    url: file.webViewLink,
+                }));
+                return JSON.stringify({ files, total: files.length }, 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/drive/listFolderContents.js

@@ -0,0 +1,83 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDriveClient } from '../../clients.js';
+import { escapeDriveQuery } from '../../driveQueryUtils.js';
+export function register(server) {
+    server.addTool({
+        name: 'listFolderContents',
+        description: "Lists files and subfolders within a Drive folder. Use folderId='root' to browse the top-level of the Drive.",
+        parameters: z.strictObject({
+            folderId: z
+                .string()
+                .describe('ID of the folder to list contents of. Use "root" for the root Drive folder.'),
+            includeSubfolders: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe('Whether to include subfolders in results.'),
+            includeFiles: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe('Whether to include files in results.'),
+            maxResults: z
+                .number()
+                .int()
+                .min(1)
+                .max(100)
+                .optional()
+                .default(50)
+                .describe('Maximum number of items to return.'),
+        }),
+        execute: async (args, { log }) => {
+            const drive = await getDriveClient();
+            log.info(`Listing contents of folder: ${args.folderId}`);
+            try {
+                let queryString = `'${escapeDriveQuery(args.folderId)}' in parents and trashed=false`;
+                // Filter by type if specified
+                if (!args.includeSubfolders && !args.includeFiles) {
+                    throw new UserError('At least one of includeSubfolders or includeFiles must be true.');
+                }
+                if (!args.includeSubfolders) {
+                    queryString += ` and mimeType!='application/vnd.google-apps.folder'`;
+                }
+                else if (!args.includeFiles) {
+                    queryString += ` and mimeType='application/vnd.google-apps.folder'`;
+                }
+                const response = await drive.files.list({
+                    q: queryString,
+                    pageSize: args.maxResults,
+                    orderBy: 'folder,name',
+                    fields: 'files(id,name,mimeType,size,modifiedTime,webViewLink,owners(displayName))',
+                    supportsAllDrives: true,
+                    includeItemsFromAllDrives: true,
+                });
+                const items = response.data.files || [];
+                const folders = items
+                    .filter((f) => f.mimeType === 'application/vnd.google-apps.folder')
+                    .map((f) => ({
+                    id: f.id,
+                    name: f.name,
+                    modifiedTime: f.modifiedTime,
+                }));
+                const files = items
+                    .filter((f) => f.mimeType !== 'application/vnd.google-apps.folder')
+                    .map((f) => ({
+                    id: f.id,
+                    name: f.name,
+                    mimeType: f.mimeType,
+                    modifiedTime: f.modifiedTime,
+                }));
+                return JSON.stringify({ folders, files }, null, 2);
+            }
+            catch (error) {
+                log.error(`Error listing folder contents: ${error.message || error}`);
+                if (error.code === 404)
+                    throw new UserError('Folder not found. Check the folder ID.');
+                if (error.code === 403)
+                    throw new UserError('Permission denied. Make sure you have access to this folder.');
+                throw new UserError(`Failed to list folder contents: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}