google-tools-mcp 1.0.0

package/dist/tools/drive/createFromTemplate.js

@@ -0,0 +1,82 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDriveClient, getDocsClient } from '../../clients.js';
+export function register(server) {
+    server.addTool({
+        name: 'createDocumentFromTemplate',
+        description: 'Creates a new document by copying an existing template and optionally replacing placeholder text. Provide key-value pairs in the replacements parameter to substitute template variables.',
+        parameters: z.object({
+            templateId: z.string().describe('ID of the template document to copy from.'),
+            newTitle: z.string().min(1).describe('Title for the new document.'),
+            parentFolderId: z
+                .string()
+                .optional()
+                .describe('ID of folder where document should be created. If not provided, creates in Drive root.'),
+            replacements: z
+                .record(z.string())
+                .optional()
+                .describe('Key-value pairs for text replacements in the template (e.g., {"{{NAME}}": "John Doe", "{{DATE}}": "2024-01-01"}).'),
+        }),
+        execute: async (args, { log }) => {
+            const drive = await getDriveClient();
+            log.info(`Creating document from template ${args.templateId} with title "${args.newTitle}"`);
+            try {
+                // First copy the template
+                const copyMetadata = {
+                    name: args.newTitle,
+                };
+                if (args.parentFolderId) {
+                    copyMetadata.parents = [args.parentFolderId];
+                }
+                const response = await drive.files.copy({
+                    fileId: args.templateId,
+                    requestBody: copyMetadata,
+                    fields: 'id,name,webViewLink',
+                    supportsAllDrives: true,
+                });
+                const document = response.data;
+                let result = `Successfully created document "${document.name}" from template (ID: ${document.id})\nView Link: ${document.webViewLink}`;
+                // Apply text replacements if provided
+                if (args.replacements && Object.keys(args.replacements).length > 0) {
+                    try {
+                        const docs = await getDocsClient();
+                        const requests = [];
+                        // Create replace requests for each replacement
+                        for (const [searchText, replaceText] of Object.entries(args.replacements)) {
+                            requests.push({
+                                replaceAllText: {
+                                    containsText: {
+                                        text: searchText,
+                                        matchCase: false,
+                                    },
+                                    replaceText: replaceText,
+                                },
+                            });
+                        }
+                        if (requests.length > 0) {
+                            await docs.documents.batchUpdate({
+                                documentId: document.id,
+                                requestBody: { requests },
+                            });
+                            const replacementCount = Object.keys(args.replacements).length;
+                            result += `\n\nApplied ${replacementCount} text replacement${replacementCount !== 1 ? 's' : ''} to the document.`;
+                        }
+                    }
+                    catch (replacementError) {
+                        log.warn(`Document created but failed to apply replacements: ${replacementError.message}`);
+                        result += `\n\nDocument created but failed to apply text replacements. You can make changes manually.`;
+                    }
+                }
+                return result;
+            }
+            catch (error) {
+                log.error(`Error creating document from template: ${error.message || error}`);
+                if (error.code === 404)
+                    throw new UserError('Template document or parent folder not found. Check the IDs.');
+                if (error.code === 403)
+                    throw new UserError('Permission denied. Make sure you have read access to the template and write access to the destination folder.');
+                throw new UserError(`Failed to create document from template: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/drive/deleteFile.js

@@ -0,0 +1,72 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDriveClient } from '../../clients.js';
+export function register(server) {
+    server.addTool({
+        name: 'deleteFile',
+        description: 'Moves a file or folder to the trash, or permanently deletes it. Set permanent=true for irreversible deletion.',
+        parameters: z.object({
+            fileId: z
+                .string()
+                .describe('The file or folder ID from a Google Drive URL or a previous tool result.'),
+            permanent: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe('If true, permanently deletes the file instead of moving it to trash.'),
+        }),
+        execute: async (args, { log }) => {
+            const drive = await getDriveClient();
+            log.info(`Deleting file ${args.fileId} ${args.permanent ? '(permanent)' : '(to trash)'}`);
+            try {
+                // Get file info before deletion
+                const fileInfo = await drive.files.get({
+                    fileId: args.fileId,
+                    fields: 'name,mimeType',
+                    supportsAllDrives: true,
+                });
+                const fileName = fileInfo.data.name;
+                const isFolder = fileInfo.data.mimeType === 'application/vnd.google-apps.folder';
+                if (args.permanent) {
+                    await drive.files.delete({
+                        fileId: args.fileId,
+                        supportsAllDrives: true,
+                    });
+                    return JSON.stringify({
+                        success: true,
+                        action: 'permanently_deleted',
+                        fileId: args.fileId,
+                        fileName,
+                        type: isFolder ? 'folder' : 'file',
+                        message: `Permanently deleted ${isFolder ? 'folder' : 'file'} "${fileName}".`,
+                    }, null, 2);
+                }
+                else {
+                    await drive.files.update({
+                        fileId: args.fileId,
+                        requestBody: {
+                            trashed: true,
+                        },
+                        supportsAllDrives: true,
+                    });
+                    return JSON.stringify({
+                        success: true,
+                        action: 'trashed',
+                        fileId: args.fileId,
+                        fileName,
+                        type: isFolder ? 'folder' : 'file',
+                        message: `Moved ${isFolder ? 'folder' : 'file'} "${fileName}" to trash. It can be restored from the trash.`,
+                    }, null, 2);
+                }
+            }
+            catch (error) {
+                log.error(`Error deleting file: ${error.message || error}`);
+                if (error.code === 404)
+                    throw new UserError('File not found. Check the file ID.');
+                if (error.code === 403)
+                    throw new UserError('Permission denied. Make sure you have delete access to this file.');
+                throw new UserError(`Failed to delete 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.object({
+            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,30 @@
+import { register as listGoogleDocs } from './listGoogleDocs.js';
+import { register as searchGoogleDocs } from './searchGoogleDocs.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 listSharedDrives } from './listSharedDrives.js';
+import { register as listSharedWithMe } from './listSharedWithMe.js';
+export function registerDriveTools(server) {
+    listGoogleDocs(server);
+    searchGoogleDocs(server);
+    getDocumentInfo(server);
+    createFolder(server);
+    listFolderContents(server);
+    getFolderInfo(server);
+    moveFile(server);
+    copyFile(server);
+    renameFile(server);
+    deleteFile(server);
+    createDocument(server);
+    createFromTemplate(server);
+    listSharedDrives(server);
+    listSharedWithMe(server);
+}

package/dist/tools/drive/listFolderContents.js

@@ -0,0 +1,82 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDriveClient } from '../../clients.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.object({
+            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 = `'${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'}`);
+            }
+        },
+    });
+}

package/dist/tools/drive/listGoogleDocs.js

@@ -0,0 +1,67 @@
+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/drive/listSharedDrives.js

@@ -0,0 +1,52 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDriveClient } from '../../clients.js';
+export function register(server) {
+    server.addTool({
+        name: 'listSharedDrives',
+        description: 'Lists all Shared Drives (Team Drives) the user has access to. Use the returned drive ID with listFolderContents to browse its contents.',
+        parameters: z.object({
+            maxResults: z
+                .number()
+                .int()
+                .min(1)
+                .max(100)
+                .optional()
+                .default(50)
+                .describe('Maximum number of shared drives to return.'),
+            pageToken: z
+                .string()
+                .optional()
+                .describe('Token for fetching the next page of results.'),
+        }),
+        execute: async (args, { log }) => {
+            const drive = await getDriveClient();
+            log.info('Listing shared drives');
+            try {
+                const response = await drive.drives.list({
+                    pageSize: args.maxResults,
+                    pageToken: args.pageToken || undefined,
+                    fields: 'nextPageToken,drives(id,name,createdTime,hidden)',
+                });
+                const drives = (response.data.drives || []).map((d) => ({
+                    id: d.id,
+                    name: d.name,
+                    createdTime: d.createdTime,
+                    hidden: d.hidden || false,
+                }));
+                const result = {
+                    drives,
+                    nextPageToken: response.data.nextPageToken || null,
+                    totalCount: drives.length,
+                };
+                return JSON.stringify(result, null, 2);
+            }
+            catch (error) {
+                log.error(`Error listing shared drives: ${error.message || error}`);
+                if (error.code === 403)
+                    throw new UserError('Permission denied. Make sure the Drive API scope includes shared drives.');
+                throw new UserError(`Failed to list shared drives: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/drive/listSharedWithMe.js

@@ -0,0 +1,97 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDriveClient } from '../../clients.js';
+export function register(server) {
+    server.addTool({
+        name: 'listSharedWithMe',
+        description: 'Lists files and folders that have been shared with the user ("Shared with me"). Returns items shared by others that are not in the user\'s own Drive. Use folder IDs with listFolderContents to navigate into shared folders.',
+        parameters: z.object({
+            mimeType: z
+                .string()
+                .optional()
+                .describe('Filter by MIME type. Use "application/vnd.google-apps.folder" for folders only, "application/vnd.google-apps.document" for Docs, "application/vnd.google-apps.spreadsheet" for Sheets, etc.'),
+            query: z
+                .string()
+                .optional()
+                .describe('Search query to filter shared items by name (uses "contains" matching).'),
+            maxResults: z
+                .number()
+                .int()
+                .min(1)
+                .max(100)
+                .optional()
+                .default(50)
+                .describe('Maximum number of items to return.'),
+            pageToken: z
+                .string()
+                .optional()
+                .describe('Token for fetching the next page of results.'),
+            orderBy: z
+                .enum(['name', 'modifiedTime', 'sharedWithMeTime'])
+                .optional()
+                .default('sharedWithMeTime')
+                .describe('How to sort results. Defaults to most recently shared first.'),
+        }),
+        execute: async (args, { log }) => {
+            const drive = await getDriveClient();
+            log.info('Listing shared with me');
+            try {
+                let queryParts = ['sharedWithMe=true', 'trashed=false'];
+                if (args.mimeType) {
+                    queryParts.push(`mimeType='${args.mimeType}'`);
+                }
+                if (args.query) {
+                    queryParts.push(`name contains '${args.query.replace(/'/g, "\\'")}'`);
+                }
+                const orderBy = args.orderBy === 'sharedWithMeTime'
+                    ? 'sharedWithMeTime desc'
+                    : args.orderBy === 'modifiedTime'
+                        ? 'modifiedTime desc'
+                        : 'name';
+                const response = await drive.files.list({
+                    q: queryParts.join(' and '),
+                    pageSize: args.maxResults,
+                    pageToken: args.pageToken || undefined,
+                    orderBy,
+                    fields: 'nextPageToken,files(id,name,mimeType,modifiedTime,sharedWithMeTime,sharingUser(displayName,emailAddress),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,
+                    sharedWithMeTime: f.sharedWithMeTime,
+                    sharedBy: f.sharingUser?.displayName || f.owners?.[0]?.displayName || null,
+                    sharedByEmail: f.sharingUser?.emailAddress || null,
+                }));
+                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,
+                    sharedWithMeTime: f.sharedWithMeTime,
+                    sharedBy: f.sharingUser?.displayName || f.owners?.[0]?.displayName || null,
+                    sharedByEmail: f.sharingUser?.emailAddress || null,
+                }));
+                const result = {
+                    folders,
+                    files,
+                    nextPageToken: response.data.nextPageToken || null,
+                    totalCount: items.length,
+                };
+                return JSON.stringify(result, null, 2);
+            }
+            catch (error) {
+                log.error(`Error listing shared items: ${error.message || error}`);
+                if (error.code === 403)
+                    throw new UserError('Permission denied. Make sure you have the correct Drive API scopes.');
+                throw new UserError(`Failed to list shared items: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/drive/moveFile.js

@@ -0,0 +1,54 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDriveClient } from '../../clients.js';
+export function register(server) {
+    server.addTool({
+        name: 'moveFile',
+        description: 'Moves a file or folder to a different Drive folder. By default adds the new parent while keeping existing parents; set removeFromAllParents=true for a true move.',
+        parameters: z.object({
+            fileId: z
+                .string()
+                .describe('The file or folder ID from a Google Drive URL or a previous tool result.'),
+            newParentId: z.string().describe('ID of the destination folder. Use "root" for Drive root.'),
+            removeFromAllParents: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe('If true, removes from all current parents. If false, adds to new parent while keeping existing parents.'),
+        }),
+        execute: async (args, { log }) => {
+            const drive = await getDriveClient();
+            log.info(`Moving file ${args.fileId} to folder ${args.newParentId}`);
+            try {
+                // First get the current parents
+                const fileInfo = await drive.files.get({
+                    fileId: args.fileId,
+                    fields: 'name,parents',
+                    supportsAllDrives: true,
+                });
+                const fileName = fileInfo.data.name;
+                const currentParents = fileInfo.data.parents || [];
+                let updateParams = {
+                    fileId: args.fileId,
+                    addParents: args.newParentId,
+                    fields: 'id,name,parents',
+                    supportsAllDrives: true,
+                };
+                if (args.removeFromAllParents && currentParents.length > 0) {
+                    updateParams.removeParents = currentParents.join(',');
+                }
+                const response = await drive.files.update(updateParams);
+                const action = args.removeFromAllParents ? 'moved' : 'copied';
+                return `Successfully ${action} "${fileName}" to new location.\nFile ID: ${response.data.id}`;
+            }
+            catch (error) {
+                log.error(`Error moving file: ${error.message || error}`);
+                if (error.code === 404)
+                    throw new UserError('File or destination folder not found. Check the IDs.');
+                if (error.code === 403)
+                    throw new UserError('Permission denied. Make sure you have write access to both source and destination.');
+                throw new UserError(`Failed to move file: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}