mcp-google-multi 6.0.0-alpha.2 → 6.0.0-alpha.21

package/dist/tools/drive.js

@@ -4,6 +4,7 @@ import { drive as driveClient } from '@googleapis/drive';
 import { accountAliasSchema, getAccountSet } from '../accounts.js';
 import { getClient } from '../client.js';
 import { handleGoogleApiError } from './_errors.js';
+import { openLocalReadStream, prepareLocalDest } from './_local-files.js';
 import { isAllowed, writeDisabledResult } from '../write-control.js';
 import { capText } from '../trim.js';
 import * as fs from 'fs';
@@ -24,6 +25,52 @@ const GOOGLE_WORKSPACE_TYPES = new Set([
     'application/vnd.google-apps.presentation',
     'application/vnd.google-apps.drawing',
 ]);
+// drive_read inlines only textual content. Beyond text/*, RFC 6839 structured-
+// syntax suffixes (+json/+xml/...) and a few bare application/* types are text
+// in practice — image/svg+xml was the motivating false "binary" refusal.
+const TEXTUAL_EXACT = new Set([
+    'application/json',
+    'application/xml',
+    'application/javascript',
+    'application/x-ndjson',
+    'application/yaml',
+    'application/x-yaml',
+    'application/sql',
+    'application/x-sh',
+    'application/csv',
+]);
+export function isTextualMime(mimeType) {
+    const bare = mimeType.split(';')[0].trim().toLowerCase();
+    if (bare.startsWith('text/'))
+        return true;
+    if (/\+(json|xml|yaml|toml|csv)$/.test(bare))
+        return true;
+    return TEXTUAL_EXACT.has(bare);
+}
+const BINARY_READ_HINT = 'Binary content cannot be inlined. Use drive_download to save the file to disk, or drive_export for Google Workspace files.';
+// Accepted alongside the full application/vnd.google-apps.* ids so the obvious
+// short spelling ("document") works; the enum advertises both.
+const CONVERT_SHORTHANDS = {
+    document: 'application/vnd.google-apps.document',
+    spreadsheet: 'application/vnd.google-apps.spreadsheet',
+    presentation: 'application/vnd.google-apps.presentation',
+    drawing: 'application/vnd.google-apps.drawing',
+};
+export function resolveConvertTarget(convertTo) {
+    if (!convertTo)
+        return undefined;
+    return CONVERT_SHORTHANDS[convertTo] ?? convertTo;
+}
+const CONVERT_TO_VALUES = [
+    'document',
+    'spreadsheet',
+    'presentation',
+    'drawing',
+    'application/vnd.google-apps.document',
+    'application/vnd.google-apps.spreadsheet',
+    'application/vnd.google-apps.presentation',
+    'application/vnd.google-apps.drawing',
+];
 // Comment/Reply fields list — Drive API requires explicit `fields` on every call.
 const COMMENT_BASE_FIELDS = 'id,kind,content,htmlContent,createdTime,modifiedTime,resolved,anchor,author,deleted,quotedFileContent';
 const REPLY_SUBFIELDS = 'id,content,action,createdTime,modifiedTime,author,deleted';
@@ -31,12 +78,6 @@ const COMMENT_FIELDS = `${COMMENT_BASE_FIELDS},replies(${REPLY_SUBFIELDS})`;
 const COMMENT_LIST_FIELDS = `nextPageToken,comments(${COMMENT_BASE_FIELDS},replies(${REPLY_SUBFIELDS}))`;
 const REPLY_FIELDS = `kind,htmlContent,${REPLY_SUBFIELDS}`;
 const REPLY_LIST_FIELDS = `nextPageToken,replies(${REPLY_FIELDS})`;
-// path.basename() is a traversal guard — a caller-supplied filename must never escape savePath.
-export function prepareLocalDest(savePath, filename) {
-    const dest = path.join(savePath, path.basename(filename));
-    fs.mkdirSync(savePath, { recursive: true });
-    return dest;
-}
 export const DRIVE_QUERY_HINT = "Drive search syntax: a plain keyword is treated as a full-text search, but a " +
     "structured query needs an operator, e.g. \"name contains 'report'\", " +
     "\"mimeType = 'application/pdf'\", or \"'me' in owners\". " +
@@ -131,7 +172,7 @@ export function registerDriveTools(server) {
     });
     server.registerTool('drive_read', {
         _meta: { 'anthropic/maxResultSizeChars': 100_000 },
-        description: 'Read the content of a Google Drive file (returns up to maxChars characters per call; non-Google-native files over 2MB return too_large)',
+        description: 'Read the content of a Google Drive file: Workspace docs and textual types (text/*, JSON/XML/SVG and similar) inline; other binaries return error:binary (returns up to maxChars characters per call; non-Google-native files over 2MB return too_large)',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
             fileId: z.string().describe('Google Drive file ID'),
@@ -184,6 +225,7 @@ export function registerDriveTools(server) {
                                 name,
                                 mimeType,
                                 error: 'binary',
+                                hint: BINARY_READ_HINT,
                                 webViewLink,
                             }, null, 2),
                         }],
@@ -204,7 +246,7 @@ export function registerDriveTools(server) {
                         }],
                 };
             }
-            if (mimeType?.startsWith('text/')) {
+            if (mimeType && isTextualMime(mimeType)) {
                 const downloaded = await drive.files.get({ fileId, alt: 'media', supportsAllDrives: true }, { responseType: 'text' });
                 return respond(String(downloaded.data));
             }
@@ -216,6 +258,7 @@ export function registerDriveTools(server) {
                             name,
                             mimeType,
                             error: 'binary',
+                            hint: BINARY_READ_HINT,
                             webViewLink,
                         }, null, 2),
                     }],
@@ -259,15 +302,10 @@ export function registerDriveTools(server) {
         description: 'Upload a local file to Google Drive. Pass `convertTo` to import it as a native, editable Google Doc/Sheet/Slides/Drawing instead of storing the raw bytes.',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
-            localPath: z.string().describe('Absolute path to file on disk'),
+            localPath: z.string().describe('Absolute path of the SOURCE file on disk to upload (on the machine running the server; this is not savePath)'),
             filename: z.string().describe('Name as it appears in Drive'),
             mimeType: z.string().optional().describe('Source MIME type of the local file (inferred from extension if omitted). With `convertTo`, this is the format Drive imports from.'),
-            convertTo: z.enum([
-                'application/vnd.google-apps.document',
-                'application/vnd.google-apps.spreadsheet',
-                'application/vnd.google-apps.presentation',
-                'application/vnd.google-apps.drawing',
-            ]).optional().describe('Convert the upload into this native Google Workspace type on import (e.g. upload .md/.html/.docx/.txt with convertTo=...google-apps.document to get a real Google Doc). Source must be an importable format. Omit to store the file as-is.'),
+            convertTo: z.enum(CONVERT_TO_VALUES).optional().describe('Convert the upload into this native Google Workspace type on import: "document" | "spreadsheet" | "presentation" | "drawing" (full application/vnd.google-apps.* ids also accepted). E.g. upload .md/.html/.docx/.txt with convertTo=document to get a real Google Doc. Source must be an importable format. Omit to store the file as-is.'),
             parentFolderId: z.string().optional().describe('Parent folder ID (defaults to My Drive root)'),
         },
     }, async ({ account, localPath, filename, mimeType: mimeTypeArg, convertTo, parentFolderId }) => {
@@ -275,13 +313,13 @@ export function registerDriveTools(server) {
             const auth = await getClient(account);
             const drive = driveClient({ version: 'v3', auth });
             const resolvedMime = mimeTypeArg ?? (mime.lookup(localPath) || 'application/octet-stream');
-            const fileStream = fs.createReadStream(localPath);
+            const fileStream = await openLocalReadStream(localPath);
             const res = await drive.files.create({
                 requestBody: {
                     name: filename,
                     parents: parentFolderId ? [parentFolderId] : undefined,
                     // Setting a google-apps target type makes Drive convert the media on import.
-                    ...(convertTo ? { mimeType: convertTo } : {}),
+                    ...(convertTo ? { mimeType: resolveConvertTarget(convertTo) } : {}),
                 },
                 media: {
                     mimeType: resolvedMime,
@@ -303,14 +341,17 @@ export function registerDriveTools(server) {
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
             fileId: z.string().describe('Google Drive file ID'),
-            savePath: z.string().describe('Absolute directory path to save into'),
-            filename: z.string().describe('Filename to save as'),
+            savePath: z.string().describe('Absolute DIRECTORY path to save into (created if missing, on the machine running the server); the file name comes from `filename`'),
+            filename: z.string().optional().describe('Filename to save as (defaults to the file name in Drive)'),
         },
     }, async ({ account, fileId, savePath, filename }) => {
         try {
             const auth = await getClient(account);
             const drive = driveClient({ version: 'v3', auth });
-            const dest = prepareLocalDest(savePath, filename);
+            const name = filename
+                ?? (await drive.files.get({ fileId, fields: 'name', supportsAllDrives: true })).data.name
+                ?? fileId;
+            const dest = prepareLocalDest(savePath, name);
             const res = await drive.files.get({ fileId, alt: 'media', supportsAllDrives: true }, { responseType: 'stream' });
             // pipeline destroys both streams on source/sink error; raw .pipe leaks the partial file.
             await pipeline(res.data, fs.createWriteStream(dest, { mode: 0o600 }));
@@ -329,14 +370,20 @@ export function registerDriveTools(server) {
             account: accountEnum.describe('Google account alias'),
             fileId: z.string().describe('Google Drive file ID'),
             mimeType: z.string().describe('Target export MIME type (e.g. "application/pdf", "text/markdown", "application/vnd.openxmlformats-officedocument.wordprocessingml.document")'),
-            savePath: z.string().describe('Absolute directory path to save into'),
-            filename: z.string().describe('Filename to save as'),
+            savePath: z.string().describe('Absolute DIRECTORY path to save into (created if missing, on the machine running the server); the file name comes from `filename`'),
+            filename: z.string().optional().describe('Filename to save as (defaults to the Drive name plus the extension implied by mimeType)'),
         },
     }, async ({ account, fileId, mimeType: exportMime, savePath, filename }) => {
         try {
             const auth = await getClient(account);
             const drive = driveClient({ version: 'v3', auth });
-            const dest = prepareLocalDest(savePath, filename);
+            let name = filename;
+            if (!name) {
+                const meta = await drive.files.get({ fileId, fields: 'name', supportsAllDrives: true });
+                const ext = mime.extension(exportMime);
+                name = `${meta.data.name ?? fileId}${ext ? `.${ext}` : ''}`;
+            }
+            const dest = prepareLocalDest(savePath, name);
             const res = await drive.files.export({ fileId, mimeType: exportMime }, { responseType: 'stream' });
             // pipeline destroys both streams on source/sink error; raw .pipe leaks the partial file.
             await pipeline(res.data, fs.createWriteStream(dest, { mode: 0o600 }));
@@ -384,14 +431,9 @@ export function registerDriveTools(server) {
             fileId: z.string().describe('Google Drive file ID'),
             newName: z.string().optional().describe('New filename'),
             newParentFolderId: z.string().optional().describe('Move to this folder'),
-            localPath: z.string().optional().describe('Replace file content with this local file'),
+            localPath: z.string().optional().describe('Replace file content with this local file (path on the machine running the server)'),
             mimeType: z.string().optional().describe('MIME type of the replacement file (required if localPath is provided)'),
-            convertTo: z.enum([
-                'application/vnd.google-apps.document',
-                'application/vnd.google-apps.spreadsheet',
-                'application/vnd.google-apps.presentation',
-                'application/vnd.google-apps.drawing',
-            ]).optional().describe('When replacing content via localPath, convert the new content into this native Google Workspace type on import (e.g. replace a Google Doc body from a local .docx). Source must be an importable format.'),
+            convertTo: z.enum(CONVERT_TO_VALUES).optional().describe('When replacing content via localPath, convert the new content into this native Google Workspace type on import: "document" | "spreadsheet" | "presentation" | "drawing" (full application/vnd.google-apps.* ids also accepted).'),
         },
     }, async ({ account, fileId, newName, newParentFolderId, localPath: localPathArg, mimeType: mimeTypeArg, convertTo }) => {
         try {
@@ -414,10 +456,10 @@ export function registerDriveTools(server) {
             if (localPathArg) {
                 params.media = {
                     mimeType: mimeTypeArg ?? (mime.lookup(localPathArg) || 'application/octet-stream'),
-                    body: fs.createReadStream(localPathArg),
+                    body: await openLocalReadStream(localPathArg),
                 };
                 if (convertTo)
-                    requestBody.mimeType = convertTo;
+                    requestBody.mimeType = resolveConvertTarget(convertTo);
             }
             const res = await drive.files.update(params);
             return {
@@ -1440,7 +1482,7 @@ async function downloadAndUpload(sourceDrive, targetDrive, fileId, sourceMime, p
             },
             media: {
                 mimeType: plan.kind === 'native' ? plan.exportMime : (sourceMime ?? 'application/octet-stream'),
-                body: fs.createReadStream(tmp),
+                body: await openLocalReadStream(tmp),
             },
             supportsAllDrives: true,
             fields: 'id,name,mimeType,webViewLink',

package/dist/tools/generated/_shared.d.ts

@@ -13,6 +13,12 @@ export interface GeneratedToolDef {
     method: ApiMethodRef;
     params: GeneratedParam[];
     hasBody: boolean;
+    /** Typed-body tier: these top-level args assemble into the request body
+     * (flat schemas only; deep schemas keep the single opaque `body` arg). */
+    bodyParams?: Array<{
+        field: string;
+        api: string;
+    }>;
     shape: z.ZodRawShape;
 }
 export declare function accountField(): z.ZodOptional<z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>>;

package/dist/tools/generated/_shared.js

@@ -25,11 +25,21 @@ export function registerGeneratedTool(registry, def, deps = {}) {
             else
                 queryParams[p.api] = value;
         }
+        let body = def.hasBody ? args.body : undefined;
+        if (def.bodyParams) {
+            const assembled = {};
+            for (const bp of def.bodyParams) {
+                const value = args[bp.field];
+                if (value !== undefined)
+                    assembled[bp.api] = value;
+            }
+            body = assembled;
+        }
         return executeApiMethod(def.method, {
             account: args.account,
             pathParams,
             queryParams,
-            body: def.hasBody ? args.body : undefined,
+            body,
         }, deps);
     });
 }