@piotr-agier/google-drive-mcp 1.7.5 → 1.7.6

package/README.md

@@ -189,21 +189,14 @@ npx @piotr-agier/google-drive-mcp auth
 
 ### Running the Docker Container
 
-Run the container with your credentials and tokens mounted:
+The `scripts/docker-mcp.sh` wrapper manages the container lifecycle — it creates, reuses, and replaces containers automatically. MCP clients invoke this script directly (see configuration below).
+
+To verify the image works after a rebuild:
 
 ```bash
-docker run -it \
-  -v /path/to/gcp-oauth.keys.json:/config/gcp-oauth.keys.json:ro \
-  -v "$HOME/.config/google-drive-mcp/tokens.json":/config/tokens.json \
-  google-drive-mcp
+docker run --rm google-drive-mcp --help
 ```
 
-**Important Notes:**
-- Replace `/path/to/gcp-oauth.keys.json` with the actual path to your OAuth credentials
-- The `:ro` flag mounts the credentials as read-only for security
-- Tokens are mounted read-write to allow automatic refresh
-- The container runs as non-root user for security
-
 ### Docker Configuration for Claude Desktop
 
 #### Option A: Reusable container (recommended)
@@ -228,6 +221,7 @@ The script will:
 - Create the container on first run
 - Reuse the existing container on subsequent runs
 - Automatically restart it if it was stopped
+- Replace the container when the image has been rebuilt
 
 **Note:** The container stays running in the background until explicitly stopped.
 To stop it: `docker stop google-drive-mcp`
@@ -525,6 +519,12 @@ Add the server to your Claude Desktop configuration:
 - **readSmartChips** - Read smart chip-like elements (person mentions, rich links, date chips) from the default tab of a document. Only the default tab is scanned; other tabs are not included.
   - `documentId`: Document ID
 
+- **createFootnote** - Create a footnote in a Google Doc. Footnotes cannot be inserted inside equations, headers, footers, or other footnotes.
+  - `documentId`: Document ID
+  - `index`: 1-based character index where the footnote reference should be inserted (optional — provide this or `endOfSegment`)
+  - `endOfSegment`: If true, insert footnote at the end of the document body (optional — provide this or `index`)
+  - `content`: Optional text content for the footnote body
+
 - **listGoogleDocs** - List Google Documents with optional filtering
   - `query`: Search query to filter by name or content (optional)
   - `maxResults`: Maximum documents to return, 1-100 (optional, default: 20)
@@ -1081,11 +1081,9 @@ npx @piotr-agier/google-drive-mcp auth
 # 2. Verify tokens exist
 ls -la ~/.config/google-drive-mcp/tokens.json
 
-# 3. Run Docker with tokens mounted
-docker run -it \
-  -v $(pwd)/gcp-oauth.keys.json:/config/gcp-oauth.keys.json:ro \
-  -v "$HOME/.config/google-drive-mcp/tokens.json":/config/tokens.json \
-  google-drive-mcp
+# 3. Rebuild the image and restart the client
+docker build -t google-drive-mcp .
+# The client will invoke scripts/docker-mcp.sh, which auto-replaces the stale container
 ```
 
 #### "npm ci failed" during Docker build

package/dist/index.js

@@ -892,6 +892,7 @@ async function downloadDriveFile(drive, args, log2) {
 
 // src/tools/drive.ts
 var FOLDER_MIME_TYPE = "application/vnd.google-apps.folder";
+var SHORTCUT_MIME_TYPE = "application/vnd.google-apps.shortcut";
 var BINARY_MIME_TYPES = {
   jpg: "image/jpeg",
   jpeg: "image/jpeg",
@@ -976,6 +977,19 @@ var CopyFileSchema = z.object({
   newName: z.string().optional(),
   parentFolderId: z.string().optional()
 });
+var CreateShortcutSchema = z.object({
+  targetFileId: z.string().min(1, "Target file ID is required"),
+  parentFolderId: z.string().optional(),
+  shortcutName: z.string().optional()
+});
+var LockFileSchema = z.object({
+  fileId: z.string().min(1, "File ID is required"),
+  reason: z.string().optional(),
+  ownerRestricted: z.boolean().optional()
+});
+var UnlockFileSchema = z.object({
+  fileId: z.string().min(1, "File ID is required")
+});
 var UploadFileSchema = z.object({
   localPath: z.string().min(1, "Local file path is required"),
   name: z.string().optional(),
@@ -1200,7 +1214,7 @@ var toolDefinitions = [
       properties: {
         fileId: { type: "string", description: "ID of the file to copy" },
         newName: { type: "string", description: "Name for the copied file. If not provided, will use 'Copy of [original name]'" },
-        parentFolderId: { type: "string", description: "ID of folder where copy should be placed. If not provided, places in same location as original." }
+        parentFolderId: { type: "string", description: "ID or path of the destination folder (defaults to same folder as original)" }
       },
       required: ["fileId"]
     }
@@ -1392,6 +1406,64 @@ var toolDefinitions = [
         fileId: { type: "string", description: "Optional file ID for targeted access check" }
       }
     }
+  },
+  {
+    name: "createShortcut",
+    description: "Create a shortcut (link) to a file or folder in Google Drive. Useful for referencing the same document from multiple locations without duplicating it.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        targetFileId: {
+          type: "string",
+          description: "The file or folder ID (not a path) to create a shortcut to"
+        },
+        parentFolderId: {
+          type: "string",
+          description: "ID or path of the folder where the shortcut will be created"
+        },
+        shortcutName: {
+          type: "string",
+          description: "Custom name for the shortcut (defaults to original file name)"
+        }
+      },
+      required: ["targetFileId"]
+    }
+  },
+  {
+    name: "lockFile",
+    description: "Lock a file to prevent editing by setting content restrictions. The file remains readable but cannot be modified until unlocked.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        fileId: {
+          type: "string",
+          description: "ID of the file to lock"
+        },
+        reason: {
+          type: "string",
+          description: "Reason for locking the file (shown to users who try to edit)"
+        },
+        ownerRestricted: {
+          type: "boolean",
+          description: "If true, only the file owner can unlock the file (default: false)"
+        }
+      },
+      required: ["fileId"]
+    }
+  },
+  {
+    name: "unlockFile",
+    description: "Unlock a previously locked file by removing content restrictions, restoring full edit access.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        fileId: {
+          type: "string",
+          description: "ID of the file to unlock"
+        }
+      },
+      required: ["fileId"]
+    }
   }
 ];
 async function handleTool(toolName, args, ctx) {
@@ -1729,7 +1801,8 @@ More results available. Use pageToken: ${res.data.nextPageToken}`;
         name: data.newName || `Copy of ${originalFile.data.name}`
       };
       if (data.parentFolderId) {
-        copyMetadata.parents = [data.parentFolderId];
+        const resolvedParentId = await ctx.resolveFolderId(data.parentFolderId);
+        copyMetadata.parents = [resolvedParentId];
       } else if (originalFile.data.parents) {
         copyMetadata.parents = originalFile.data.parents;
       }
@@ -1746,6 +1819,136 @@ Link: ${response.data.webViewLink}` }],
         isError: false
       };
     }
+    case "createShortcut": {
+      const validation = CreateShortcutSchema.safeParse(args);
+      if (!validation.success) {
+        return errorResponse(validation.error.errors[0].message);
+      }
+      const data = validation.data;
+      const parentId = await ctx.resolveFolderId(data.parentFolderId);
+      const targetFile = await ctx.getDrive().files.get({
+        fileId: data.targetFileId,
+        fields: "id, name, mimeType",
+        supportsAllDrives: true
+      });
+      const shortcutName = data.shortcutName || targetFile.data.name || "Shortcut";
+      const shortcut = await ctx.getDrive().files.create({
+        requestBody: {
+          name: shortcutName,
+          mimeType: SHORTCUT_MIME_TYPE,
+          shortcutDetails: {
+            targetId: data.targetFileId
+          },
+          parents: [parentId]
+        },
+        fields: "id, name, webViewLink, shortcutDetails",
+        supportsAllDrives: true
+      });
+      ctx.log("Shortcut created", {
+        shortcutId: shortcut.data.id,
+        targetId: data.targetFileId,
+        name: shortcutName
+      });
+      return {
+        content: [{
+          type: "text",
+          text: `Shortcut created successfully!
+
+Shortcut: ${shortcut.data.name} (${shortcut.data.id})
+Target: ${targetFile.data.name} (${data.targetFileId})
+Location: folder ${parentId}
+Link: ${shortcut.data.webViewLink || "N/A"}`
+        }],
+        isError: false
+      };
+    }
+    case "lockFile": {
+      const validation = LockFileSchema.safeParse(args);
+      if (!validation.success) {
+        return errorResponse(validation.error.errors[0].message);
+      }
+      const data = validation.data;
+      const fileInfo = await ctx.getDrive().files.get({
+        fileId: data.fileId,
+        fields: "id, name, contentRestrictions",
+        supportsAllDrives: true
+      });
+      const existingRestrictions = fileInfo.data.contentRestrictions || [];
+      if (existingRestrictions.some((r) => r.readOnly)) {
+        return {
+          content: [{
+            type: "text",
+            text: `File "${fileInfo.data.name}" is already locked.`
+          }],
+          isError: false
+        };
+      }
+      await ctx.getDrive().files.update({
+        fileId: data.fileId,
+        requestBody: {
+          contentRestrictions: [{
+            readOnly: true,
+            reason: data.reason || "Locked via MCP",
+            ownerRestricted: data.ownerRestricted ?? false
+          }]
+        },
+        supportsAllDrives: true
+      });
+      ctx.log("File locked", { fileId: data.fileId, name: fileInfo.data.name, reason: data.reason });
+      return {
+        content: [{
+          type: "text",
+          text: `File locked successfully!
+
+File: ${fileInfo.data.name}
+Reason: ${data.reason || "Locked via MCP"}${data.ownerRestricted ? "\nOwner-restricted: only the file owner can unlock" : ""}
+
+The file is now read-only and cannot be edited or deleted.`
+        }],
+        isError: false
+      };
+    }
+    case "unlockFile": {
+      const validation = UnlockFileSchema.safeParse(args);
+      if (!validation.success) {
+        return errorResponse(validation.error.errors[0].message);
+      }
+      const data = validation.data;
+      const fileInfo = await ctx.getDrive().files.get({
+        fileId: data.fileId,
+        fields: "id, name, contentRestrictions",
+        supportsAllDrives: true
+      });
+      const existingRestrictions = fileInfo.data.contentRestrictions || [];
+      if (!existingRestrictions.some((r) => r.readOnly)) {
+        return {
+          content: [{
+            type: "text",
+            text: `File "${fileInfo.data.name}" is not locked.`
+          }],
+          isError: false
+        };
+      }
+      await ctx.getDrive().files.update({
+        fileId: data.fileId,
+        requestBody: {
+          contentRestrictions: [{ readOnly: false }]
+        },
+        supportsAllDrives: true
+      });
+      ctx.log("File unlocked", { fileId: data.fileId, name: fileInfo.data.name });
+      return {
+        content: [{
+          type: "text",
+          text: `File unlocked successfully!
+
+File: ${fileInfo.data.name}
+
+The file can now be edited and deleted.`
+        }],
+        isError: false
+      };
+    }
     case "uploadFile": {
       const validation = UploadFileSchema.safeParse(args);
       if (!validation.success) {
@@ -3046,6 +3249,14 @@ var InsertSmartChipSchema = z2.object({
 var ReadSmartChipsSchema = z2.object({
   documentId: z2.string().min(1, "Document ID is required")
 });
+var CreateFootnoteSchema = z2.object({
+  documentId: z2.string().min(1, "Document ID is required"),
+  index: z2.number().int().min(1, "Index must be at least 1").optional(),
+  endOfSegment: z2.boolean().optional(),
+  content: z2.string().optional()
+}).refine((data) => data.index !== void 0 || data.endOfSegment === true, {
+  message: "Either 'index' or 'endOfSegment: true' must be provided"
+});
 var toolDefinitions2 = [
   {
     name: "createGoogleDoc",
@@ -3465,6 +3676,20 @@ var toolDefinitions2 = [
       },
       required: ["documentId"]
     }
+  },
+  {
+    name: "createFootnote",
+    description: "Create a footnote in a Google Doc. Footnotes cannot be inserted inside equations, headers, footers, or other footnotes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        documentId: { type: "string", description: "Document ID" },
+        index: { type: "number", description: "1-based character index where the footnote reference should be inserted" },
+        endOfSegment: { type: "boolean", description: "If true, insert footnote at the end of the document body (use instead of index)" },
+        content: { type: "string", description: "Optional text content for the footnote body" }
+      },
+      required: ["documentId"]
+    }
   }
 ];
 async function handleTool2(toolName, args, ctx) {
@@ -3590,37 +3815,106 @@ Link: ${doc.webViewLink}` }],
     // DOC CONTENT
     // =========================================================================
     case "getGoogleDocContent": {
-      let extractSegments2 = function(bodyContent) {
+      let resolveInlineElementText2 = function(el, inlineObjects) {
+        if (el.person?.personProperties) {
+          const p = el.person.personProperties;
+          if (p.name && p.email) return `@${p.name} (${p.email})`;
+          return `@${p.name || p.email || ""}`;
+        }
+        if (el.richLink?.richLinkProperties) {
+          const rl = el.richLink.richLinkProperties;
+          const title = (rl.title || rl.uri || "").replace(/[\[\]]/g, "\\$&");
+          const uri = rl.uri;
+          return title && uri ? `[${title}](${uri})` : title || null;
+        }
+        if (el.inlineObjectElement?.inlineObjectId) {
+          if (inlineObjects) {
+            const obj = inlineObjects[el.inlineObjectElement.inlineObjectId];
+            const desc = obj?.inlineObjectProperties?.embeddedObject?.description || obj?.inlineObjectProperties?.embeddedObject?.title;
+            return desc ? `[image: ${desc}]` : "[image]";
+          }
+          return "[image]";
+        }
+        if (el.footnoteReference) {
+          return `[^${el.footnoteReference.footnoteNumber || ""}]`;
+        }
+        if (el.horizontalRule) {
+          return "---\n";
+        }
+        return null;
+      }, extractSegments2 = function(bodyContent, inlineObjects) {
         const segments = [];
-        for (const element of bodyContent) {
-          if (element.paragraph?.elements) {
-            for (const textElement of element.paragraph.elements) {
-              if (textElement.textRun?.content && textElement.startIndex != null && textElement.endIndex != null) {
-                const seg = {
-                  text: textElement.textRun.content,
-                  startIndex: textElement.startIndex,
-                  endIndex: textElement.endIndex
-                };
-                if (withFormatting) {
-                  const ts = textElement.textRun.textStyle;
-                  if (ts) {
-                    if (ts.weightedFontFamily?.fontFamily) seg.fontFamily = ts.weightedFontFamily.fontFamily;
-                    if (ts.fontSize?.magnitude != null) seg.fontSize = ts.fontSize.magnitude;
-                    if (ts.bold) seg.bold = true;
-                    if (ts.italic) seg.italic = true;
-                    if (ts.underline) seg.underline = true;
-                    if (ts.strikethrough) seg.strikethrough = true;
-                    const fg = rgbColorToHex(ts.foregroundColor);
-                    const bg = rgbColorToHex(ts.backgroundColor);
-                    if (fg) seg.foregroundColor = fg;
-                    if (bg) seg.backgroundColor = bg;
+        function getCellText(cellContent) {
+          const before = segments.length;
+          processContent(cellContent);
+          const cellSegs = segments.splice(before);
+          return cellSegs.map((s) => s.text.replace(/\n$/g, "")).join(" ").replace(/\|/g, "\\|").trim();
+        }
+        function processContent(content) {
+          for (const element of content) {
+            if (element.paragraph?.elements) {
+              for (const textElement of element.paragraph.elements) {
+                if (textElement.textRun?.content && textElement.startIndex != null && textElement.endIndex != null) {
+                  const seg = {
+                    text: textElement.textRun.content,
+                    startIndex: textElement.startIndex,
+                    endIndex: textElement.endIndex
+                  };
+                  if (withFormatting) {
+                    const ts = textElement.textRun.textStyle;
+                    if (ts) {
+                      if (ts.weightedFontFamily?.fontFamily) seg.fontFamily = ts.weightedFontFamily.fontFamily;
+                      if (ts.fontSize?.magnitude != null) seg.fontSize = ts.fontSize.magnitude;
+                      if (ts.bold) seg.bold = true;
+                      if (ts.italic) seg.italic = true;
+                      if (ts.underline) seg.underline = true;
+                      if (ts.strikethrough) seg.strikethrough = true;
+                      const fg = rgbColorToHex(ts.foregroundColor);
+                      const bg = rgbColorToHex(ts.backgroundColor);
+                      if (fg) seg.foregroundColor = fg;
+                      if (bg) seg.backgroundColor = bg;
+                    }
+                  }
+                  segments.push(seg);
+                } else {
+                  const inlineText = resolveInlineElementText2(textElement, inlineObjects);
+                  if (inlineText && textElement.startIndex != null && textElement.endIndex != null) {
+                    segments.push({
+                      text: inlineText,
+                      startIndex: textElement.startIndex,
+                      endIndex: textElement.endIndex
+                    });
                   }
                 }
-                segments.push(seg);
               }
+            } else if (element.table?.tableRows) {
+              const rows = [];
+              for (let rowIdx = 0; rowIdx < element.table.tableRows.length; rowIdx++) {
+                const row = element.table.tableRows[rowIdx];
+                if (!row.tableCells) continue;
+                const cellTexts = [];
+                for (const cell of row.tableCells) {
+                  cellTexts.push(cell.content ? getCellText(cell.content) : "");
+                }
+                rows.push("| " + cellTexts.join(" | ") + " |");
+                if (rowIdx === 0) {
+                  rows.push("| " + cellTexts.map(() => "---").join(" | ") + " |");
+                }
+              }
+              const md = rows.join("\n") + "\n\n";
+              if (element.startIndex != null && element.endIndex != null) {
+                segments.push({
+                  text: md,
+                  startIndex: element.startIndex,
+                  endIndex: element.endIndex
+                });
+              }
+            } else if (element.tableOfContents?.content) {
+              processContent(element.tableOfContents.content);
             }
           }
         }
+        processContent(bodyContent);
         return segments;
       }, formatSegments2 = function(segments) {
         let result = "";
@@ -3677,7 +3971,7 @@ Link: ${doc.webViewLink}` }],
           }
         }
       };
-      var extractSegments = extractSegments2, formatSegments = formatSegments2, hasFormattingInfo = hasFormattingInfo2, buildMetaLine = buildMetaLine2, trackFonts = trackFonts2;
+      var resolveInlineElementText = resolveInlineElementText2, extractSegments = extractSegments2, formatSegments = formatSegments2, hasFormattingInfo = hasFormattingInfo2, buildMetaLine = buildMetaLine2, trackFonts = trackFonts2;
       const validation = GetGoogleDocContentSchema.safeParse(args);
       if (!validation.success) {
         return errorResponse(validation.error.errors[0].message);
@@ -3705,7 +3999,8 @@ Link: ${doc.webViewLink}` }],
 `;
           }
           if (bodyContent) {
-            const segments = extractSegments2(bodyContent);
+            const tabInlineObjects = tab.documentTab?.inlineObjects;
+            const segments = extractSegments2(bodyContent, tabInlineObjects);
             trackFonts2(segments);
             formattedContent += formatSegments2(segments);
             if (segments.length > 0) {
@@ -3719,7 +4014,8 @@ Link: ${doc.webViewLink}` }],
       } else {
         const bodyContent = document.data.body?.content;
         if (bodyContent) {
-          const segments = extractSegments2(bodyContent);
+          const legacyInlineObjects = document.data.inlineObjects;
+          const segments = extractSegments2(bodyContent, legacyInlineObjects);
           trackFonts2(segments);
           formattedContent += formatSegments2(segments);
           totalLength = segments.length > 0 ? segments[segments.length - 1].endIndex : 0;
@@ -4803,6 +5099,47 @@ Image URL: ${imageUrl}` }],
       }
       return { content: [{ type: "text", text: hits.length ? hits.join("\n") : "No smart chips detected (note: only the default tab is scanned)." }], isError: false };
     }
+    case "createFootnote": {
+      const validation = CreateFootnoteSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const a = validation.data;
+      const docs = ctx.google.docs({ version: "v1", auth: ctx.authClient });
+      const createFootnoteReq = {};
+      if (a.index !== void 0) {
+        createFootnoteReq.location = { index: a.index };
+      } else {
+        createFootnoteReq.endOfSegmentLocation = { segmentId: "" };
+      }
+      const res = await docs.documents.batchUpdate({
+        documentId: a.documentId,
+        requestBody: {
+          requests: [{ createFootnote: createFootnoteReq }]
+        }
+      });
+      const footnoteId = res.data.replies?.[0]?.createFootnote?.footnoteId;
+      if (!footnoteId) {
+        return errorResponse("Failed to create footnote \u2014 no footnoteId in response.");
+      }
+      const locationDesc = a.index !== void 0 ? `at index ${a.index}` : "at end of document";
+      if (a.content) {
+        try {
+          await docs.documents.batchUpdate({
+            documentId: a.documentId,
+            requestBody: {
+              requests: [{
+                insertText: {
+                  location: { segmentId: footnoteId, index: 0 },
+                  text: a.content
+                }
+              }]
+            }
+          });
+        } catch (err) {
+          return { content: [{ type: "text", text: `Created footnote ${footnoteId} ${locationDesc}, but failed to insert content: ${err.message}` }], isError: true };
+        }
+      }
+      return { content: [{ type: "text", text: `Created footnote ${footnoteId} ${locationDesc}.${a.content ? " Content inserted." : ""}` }], isError: false };
+    }
     default:
       return null;
   }