@piotr-agier/google-drive-mcp 1.7.0 → 1.7.1

package/README.md

@@ -400,14 +400,10 @@ Add the server to your Claude Desktop configuration:
   - `revisionId`: Revision ID to restore
   - `confirm`: Must be `true` to execute restore
 
-#### Auth Diagnostics & Scope Presets (v1.7.0)
+#### Auth Diagnostics (v1.7.0)
 - **authGetStatus** - Show token/scopes/auth health diagnostics (machine + human readable)
 - **authListScopes** - Show configured/requested scopes, granted scopes, missing scopes, and presets
 - **authTestFileAccess** - Test Drive access (optionally against a specific `fileId`)
-- **authClearTokens** - Clear saved OAuth tokens (`confirm=true` required)
-- **authSuggestScopePreset** - Get scope configuration instructions for a preset
-  - `preset`: `readonly` | `content-editor` | `full`
-  - `clearTokens`: optional best-effort token clear
 
 - **uploadFile** - Upload a local file (any type: image, audio, video, PDF, etc.) to Google Drive
   - `localPath`: Absolute path to the local file

package/dist/index.js

@@ -699,7 +699,7 @@ __export(drive_exports, {
 });
 import { z } from "zod";
 import { existsSync as existsSync2, statSync as statSync2, createReadStream } from "fs";
-import { mkdtemp, readFile as readFile3, writeFile as writeFile2, rm, unlink as unlink2 } from "fs/promises";
+import { mkdtemp, readFile as readFile3, writeFile as writeFile2, rm } from "fs/promises";
 import { tmpdir } from "os";
 import { basename as basename2, extname as extname2, join as join3 } from "path";
 import { PDFDocument } from "pdf-lib";
@@ -916,7 +916,8 @@ var BINARY_MIME_TYPES = {
 var SearchSchema = z.object({
   query: z.string().min(1, "Search query is required"),
   pageSize: z.number().int().min(1).max(100).optional(),
-  pageToken: z.string().optional()
+  pageToken: z.string().optional(),
+  rawQuery: z.boolean().optional()
 });
 var CreateTextFileSchema = z.object({
   name: z.string().min(1, "File name is required"),
@@ -1050,13 +1051,6 @@ var RestoreRevisionSchema = z.object({
 var AuthTestFileAccessSchema = z.object({
   fileId: z.string().optional()
 });
-var AuthClearTokensSchema = z.object({
-  confirm: z.boolean().optional().default(false)
-});
-var AuthSetScopePresetSchema = z.object({
-  preset: z.enum(["readonly", "content-editor", "full"]),
-  clearTokens: z.boolean().optional().default(false)
-});
 function getGrantedScopesFromAuthClient(ctx) {
   const scopeRaw = ctx.authClient?.credentials?.scope;
   if (!scopeRaw || typeof scopeRaw !== "string") return [];
@@ -1065,13 +1059,14 @@ function getGrantedScopesFromAuthClient(ctx) {
 var toolDefinitions = [
   {
     name: "search",
-    description: "Search for files in Google Drive",
+    description: "Search for files in Google Drive. Set rawQuery=true to pass a raw Google Drive API query supporting operators like modifiedTime, createdTime, mimeType, name contains, etc.",
     inputSchema: {
       type: "object",
       properties: {
-        query: { type: "string", description: "Search query" },
+        query: { type: "string", description: "Search query. When rawQuery=true, this is passed directly to the Google Drive API as the q parameter." },
         pageSize: { type: "number", description: "Results per page (default 50, max 100)" },
-        pageToken: { type: "string", description: "Token for next page of results" }
+        pageToken: { type: "string", description: "Token for next page of results" },
+        rawQuery: { type: "boolean", description: "If true, pass query directly to Google Drive API without wrapping in fullText contains. Enables date filters, mimeType filters, etc." }
       },
       required: ["query"]
     }
@@ -1371,53 +1366,71 @@ var toolDefinitions = [
         fileId: { type: "string", description: "Optional file ID for targeted access check" }
       }
     }
-  },
-  {
-    name: "authClearTokens",
-    description: "Clear saved OAuth tokens (requires confirm=true)",
-    inputSchema: {
-      type: "object",
-      properties: {
-        confirm: { type: "boolean", description: "Must be true to clear tokens" }
-      }
-    }
-  },
-  {
-    name: "authSuggestScopePreset",
-    description: "Get scope configuration instructions for a preset",
-    inputSchema: {
-      type: "object",
-      properties: {
-        preset: { type: "string", enum: ["readonly", "content-editor", "full"], description: "Scope preset" },
-        clearTokens: { type: "boolean", description: "Also clear saved tokens now" }
-      },
-      required: ["preset"]
-    }
   }
 ];
 async function handleTool(toolName, args, ctx) {
   switch (toolName) {
     case "search": {
+      let resolveParentPath2 = function(folderId, depth = 0) {
+        if (depth >= 10) return Promise.resolve(folderId);
+        if (folderId in pathCache) return pathCache[folderId];
+        const promise = (async () => {
+          try {
+            const folderRes = await ctx.getDrive().files.get({
+              fileId: folderId,
+              fields: "name, parents",
+              supportsAllDrives: true
+            });
+            const name = folderRes.data.name || folderId;
+            const parents = folderRes.data.parents;
+            if (parents && parents.length > 0 && parents[0] !== folderId) {
+              const parentPath = await resolveParentPath2(parents[0], depth + 1);
+              return `${parentPath}/${name}`;
+            }
+            return name;
+          } catch {
+            return folderId;
+          }
+        })();
+        pathCache[folderId] = promise;
+        return promise;
+      };
+      var resolveParentPath = resolveParentPath2;
       const validation = SearchSchema.safeParse(args);
       if (!validation.success) {
         return errorResponse(validation.error.errors[0].message);
       }
-      const { query: userQuery, pageSize, pageToken } = validation.data;
-      const escapedQuery = escapeDriveQuery(userQuery);
-      const formattedQuery = `fullText contains '${escapedQuery}' and trashed = false`;
+      const { query: userQuery, pageSize, pageToken, rawQuery } = validation.data;
+      let formattedQuery;
+      if (rawQuery) {
+        formattedQuery = /\btrashed\s*=/.test(userQuery) ? userQuery : `${userQuery} and trashed = false`;
+      } else {
+        const escapedQuery = escapeDriveQuery(userQuery);
+        formattedQuery = `fullText contains '${escapedQuery}' and trashed = false`;
+      }
       const res = await ctx.getDrive().files.list({
         q: formattedQuery,
         pageSize: Math.min(pageSize || 50, 100),
         pageToken,
-        fields: "nextPageToken, files(id, name, mimeType, modifiedTime, size)",
+        fields: "nextPageToken, files(id, name, mimeType, createdTime, modifiedTime, size, parents)",
         corpora: "allDrives",
         includeItemsFromAllDrives: true,
         supportsAllDrives: true
       });
-      const fileList = res.data.files?.map((f) => `${f.name} (ID: ${f.id}, ${f.mimeType})`).join("\n") || "";
-      ctx.log("Search results", { query: userQuery, resultCount: res.data.files?.length });
-      let response = `Found ${res.data.files?.length ?? 0} files:
-${fileList}`;
+      const pathCache = {};
+      const files = res.data.files || [];
+      const fileLines = await Promise.all(
+        files.map(async (f) => {
+          let folderPath = "";
+          if (f.parents && f.parents.length > 0) {
+            folderPath = await resolveParentPath2(f.parents[0]);
+          }
+          return `${f.name} (${f.mimeType}) [id: ${f.id}, path: ${folderPath || "/"}] [created: ${f.createdTime || "N/A"}, modified: ${f.modifiedTime || "N/A"}]`;
+        })
+      );
+      ctx.log("Search results", { query: userQuery, rawQuery: !!rawQuery, resultCount: files.length });
+      let response = `Found ${files.length} files:
+${fileLines.join("\n")}`;
       if (res.data.nextPageToken) {
         response += `
 
@@ -2206,62 +2219,6 @@ ${JSON.stringify({ message }, null, 2)}` }],
         };
       }
     }
-    case "authClearTokens": {
-      const validation = AuthClearTokensSchema.safeParse(args);
-      if (!validation.success) return errorResponse(validation.error.errors[0].message);
-      const data = validation.data;
-      if (!data.confirm) return errorResponse("Refusing token clear: set confirm=true.");
-      const tokenPath = getSecureTokenPath();
-      const existed = existsSync2(tokenPath);
-      if (existed) {
-        try {
-          await unlink2(tokenPath);
-        } catch (e) {
-          const msg = e instanceof Error ? e.message : String(e);
-          return errorResponse(`Failed to remove token file at ${tokenPath}: ${msg}`);
-        }
-      }
-      return {
-        content: [{ type: "text", text: `Tokens cleared. File previously ${existed ? "existed" : "did not exist"} at ${tokenPath}. Re-run auth flow before next privileged operation.` }],
-        isError: false
-      };
-    }
-    case "authSuggestScopePreset": {
-      const validation = AuthSetScopePresetSchema.safeParse(args);
-      if (!validation.success) return errorResponse(validation.error.errors[0].message);
-      const data = validation.data;
-      const aliases = SCOPE_PRESETS[data.preset];
-      const resolved = aliases.map((a) => SCOPE_ALIASES[a]);
-      const envValue = aliases.join(",");
-      let clearMessage = "";
-      if (data.clearTokens) {
-        const tokenPath = getSecureTokenPath();
-        try {
-          await unlink2(tokenPath);
-          clearMessage = `
-Tokens cleared at ${tokenPath}.`;
-        } catch (_e) {
-          clearMessage = `
-Tokens clear requested, but no token file removed.`;
-        }
-      }
-      return {
-        content: [{
-          type: "text",
-          text: `Scope preset selected: ${data.preset}
-Requested scopes: ${JSON.stringify(resolved, null, 2)}
-
-Next steps:
-1) Export scope env:
-   GOOGLE_DRIVE_MCP_SCOPES=${envValue}
-2) Restart MCP server
-3) Run auth flow to refresh consent (if prompted)
-
-This tool does not mutate process env automatically.${clearMessage}`
-        }],
-        isError: false
-      };
-    }
     default:
       return null;
   }