@piotr-agier/google-drive-mcp 2.0.2 → 2.2.0

package/dist/index.js

@@ -427,7 +427,14 @@ var AuthServer = class {
     this.baseOAuth2Client = oauth2Client;
     this.tokenManager = new TokenManager(oauth2Client);
     this.app = express();
-    this.portRange = { start: 3e3, end: 3004 };
+    const raw = process.env.GOOGLE_DRIVE_MCP_AUTH_PORT;
+    const portStart = raw ? Number(raw) : 3e3;
+    if (!Number.isInteger(portStart) || portStart < 1 || portStart > 65531) {
+      throw new Error(
+        `Invalid GOOGLE_DRIVE_MCP_AUTH_PORT: "${raw}". Must be an integer between 1 and 65531.`
+      );
+    }
+    this.portRange = { start: portStart, end: portStart + 4 };
     this.setupRoutes();
   }
   setupRoutes() {
@@ -1085,7 +1092,8 @@ var AddPermissionSchema = z.object({
   emailAddress: z.string().email("Valid email is required"),
   role: z.enum(["owner", "organizer", "fileOrganizer", "writer", "commenter", "reader"]).default("reader"),
   type: z.enum(["user", "group", "domain", "anyone"]).default("user"),
-  sendNotificationEmail: z.boolean().optional().default(false)
+  sendNotificationEmail: z.boolean().optional().default(false),
+  emailMessage: z.string().optional()
 });
 var UpdatePermissionSchema = z.object({
   fileId: z.string().min(1, "File ID is required"),
@@ -1105,7 +1113,8 @@ var ShareFileSchema = z.object({
   fileId: z.string().min(1, "File ID is required"),
   emailAddress: z.string().email("Valid email is required"),
   role: z.enum(["writer", "commenter", "reader"]).default("reader"),
-  sendNotificationEmail: z.boolean().optional().default(true)
+  sendNotificationEmail: z.boolean().optional().default(true),
+  emailMessage: z.string().optional()
 });
 var ConvertPdfToGoogleDocSchema = z.object({
   fileId: z.string().min(1, "File ID is required"),
@@ -1349,7 +1358,8 @@ var toolDefinitions = [
         emailAddress: { type: "string", description: "Target user/group email" },
         role: { type: "string", enum: ["owner", "organizer", "fileOrganizer", "writer", "commenter", "reader"], description: "Permission role" },
         type: { type: "string", enum: ["user", "group", "domain", "anyone"], description: "Principal type" },
-        sendNotificationEmail: { type: "boolean", description: "Send notification email" }
+        sendNotificationEmail: { type: "boolean", description: "Send notification email" },
+        emailMessage: { type: "string", description: "Custom message to include in the notification email. Ignored unless sendNotificationEmail is true." }
       },
       required: ["fileId", "emailAddress"]
     }
@@ -1389,7 +1399,8 @@ var toolDefinitions = [
         fileId: { type: "string", description: "Google Drive file ID" },
         emailAddress: { type: "string", description: "User email" },
         role: { type: "string", enum: ["writer", "commenter", "reader"], description: "Access role" },
-        sendNotificationEmail: { type: "boolean", description: "Send notification email" }
+        sendNotificationEmail: { type: "boolean", description: "Send notification email" },
+        emailMessage: { type: "string", description: "Custom message to include in the notification email. Ignored unless sendNotificationEmail is true." }
       },
       required: ["fileId", "emailAddress"]
     }
@@ -2139,6 +2150,7 @@ ${lines.join("\n")}` }], isError: false };
           emailAddress: data.emailAddress
         },
         sendNotificationEmail: data.sendNotificationEmail,
+        ...data.emailMessage && { emailMessage: data.emailMessage },
         fields: "id,type,role,emailAddress",
         supportsAllDrives: true
       });
@@ -2225,6 +2237,7 @@ ${lines.join("\n")}` }], isError: false };
           emailAddress: data.emailAddress
         },
         sendNotificationEmail: data.sendNotificationEmail,
+        ...data.emailMessage && { emailMessage: data.emailMessage },
         fields: "id,type,role,emailAddress",
         supportsAllDrives: true
       });
@@ -2555,9 +2568,62 @@ __export(docs_exports, {
   toolDefinitions: () => toolDefinitions2
 });
 import { z as z2 } from "zod";
-import { createReadStream as createReadStream2, existsSync as existsSync3 } from "fs";
-import { basename as basename3, extname as extname3 } from "path";
 import JSZip from "jszip";
+
+// src/utils/driveImageUpload.ts
+import { existsSync as existsSync3, createReadStream as createReadStream2 } from "fs";
+import { basename as basename3, extname as extname3 } from "path";
+var MIME_BY_EXT = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".bmp": "image/bmp",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml"
+};
+async function uploadImageToDrive(ctx, localFilePath, options = {}) {
+  const { parentFolderId, makePublic = false } = options;
+  if (!existsSync3(localFilePath)) {
+    throw new Error(`Image file not found: ${localFilePath}`);
+  }
+  const fileName = basename3(localFilePath);
+  const ext = extname3(localFilePath).toLowerCase();
+  const mimeType = MIME_BY_EXT[ext] || "application/octet-stream";
+  const requestBody = {
+    name: fileName,
+    mimeType
+  };
+  if (parentFolderId) requestBody.parents = [parentFolderId];
+  const drive = ctx.getDrive();
+  const uploadResponse = await drive.files.create({
+    requestBody,
+    media: { mimeType, body: createReadStream2(localFilePath) },
+    fields: "id,webViewLink,webContentLink",
+    supportsAllDrives: true
+  });
+  const fileId = uploadResponse.data.id;
+  if (!fileId) throw new Error("Failed to upload image to Drive - no file ID returned");
+  if (makePublic) {
+    await drive.permissions.create({
+      fileId,
+      requestBody: { role: "reader", type: "anyone" }
+    });
+  }
+  const fileInfo = await drive.files.get({
+    fileId,
+    fields: "webContentLink",
+    supportsAllDrives: true
+  });
+  const webContentLink = fileInfo.data.webContentLink;
+  if (!webContentLink) throw new Error("Failed to get web content link for uploaded image");
+  return { fileId, webContentLink };
+}
+async function deleteDriveFile(ctx, fileId) {
+  await ctx.getDrive().files.delete({ fileId, supportsAllDrives: true });
+}
+
+// src/tools/docs.ts
 function hexToRgbColor(hex) {
   if (!hex) return null;
   let hexClean = hex.startsWith("#") ? hex.slice(1) : hex;
@@ -2853,64 +2919,6 @@ async function insertInlineImageHelper(ctx, documentId, imageUrl, index, width,
   }
   return executeBatchUpdate(ctx, documentId, [request]);
 }
-async function uploadImageToDriveHelper(ctx, localFilePath, parentFolderId, makePublic = false) {
-  if (!existsSync3(localFilePath)) {
-    throw new Error(`Image file not found: ${localFilePath}`);
-  }
-  const fileName = basename3(localFilePath);
-  const mimeTypeMap = {
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".png": "image/png",
-    ".gif": "image/gif",
-    ".bmp": "image/bmp",
-    ".webp": "image/webp",
-    ".svg": "image/svg+xml"
-  };
-  const ext = extname3(localFilePath).toLowerCase();
-  const mimeType = mimeTypeMap[ext] || "application/octet-stream";
-  const fileMetadata = {
-    name: fileName,
-    mimeType
-  };
-  if (parentFolderId) {
-    fileMetadata.parents = [parentFolderId];
-  }
-  const media = {
-    mimeType,
-    body: createReadStream2(localFilePath)
-  };
-  const drive = ctx.getDrive();
-  const uploadResponse = await drive.files.create({
-    requestBody: fileMetadata,
-    media,
-    fields: "id,webViewLink,webContentLink",
-    supportsAllDrives: true
-  });
-  const fileId = uploadResponse.data.id;
-  if (!fileId) {
-    throw new Error("Failed to upload image to Drive - no file ID returned");
-  }
-  if (makePublic) {
-    await drive.permissions.create({
-      fileId,
-      requestBody: {
-        role: "reader",
-        type: "anyone"
-      }
-    });
-  }
-  const fileInfo = await drive.files.get({
-    fileId,
-    fields: "webContentLink",
-    supportsAllDrives: true
-  });
-  const webContentLink = fileInfo.data.webContentLink;
-  if (!webContentLink) {
-    throw new Error("Failed to get web content link for uploaded image");
-  }
-  return webContentLink;
-}
 var MAX_ROW_XML_DISTANCE = 1e5;
 var MAX_PARAGRAPH_XML_DISTANCE = 5e4;
 var MAX_PARAGRAPH_CONTEXT_LENGTH = 300;
@@ -3148,7 +3156,8 @@ var CreateGoogleDocSchema = z2.object({
 });
 var UpdateGoogleDocSchema = z2.object({
   documentId: z2.string().min(1, "Document ID is required"),
-  content: z2.string()
+  content: z2.string(),
+  tabId: z2.string().optional()
 });
 var GetGoogleDocContentSchema = z2.object({
   documentId: z2.string().min(1, "Document ID is required"),
@@ -3157,12 +3166,14 @@ var GetGoogleDocContentSchema = z2.object({
 var InsertTextSchema = z2.object({
   documentId: z2.string().min(1, "Document ID is required"),
   text: z2.string().min(1, "Text to insert is required"),
-  index: z2.number().int().min(1, "Index must be at least 1 (1-based)")
+  index: z2.number().int().min(1, "Index must be at least 1 (1-based)"),
+  tabId: z2.string().optional()
 });
 var DeleteRangeSchema = z2.object({
   documentId: z2.string().min(1, "Document ID is required"),
   startIndex: z2.number().int().min(1, "Start index must be at least 1"),
-  endIndex: z2.number().int().min(1, "End index must be at least 1")
+  endIndex: z2.number().int().min(1, "End index must be at least 1"),
+  tabId: z2.string().optional()
 }).refine((data) => data.endIndex > data.startIndex, {
   message: "End index must be greater than start index",
   path: ["endIndex"]
@@ -3303,7 +3314,8 @@ var FindAndReplaceInDocSchema = z2.object({
   findText: z2.string().min(1, "findText is required"),
   replaceText: z2.string(),
   matchCase: z2.boolean().optional().default(false),
-  dryRun: z2.boolean().optional().default(false)
+  dryRun: z2.boolean().optional().default(false),
+  tabId: z2.string().optional()
 });
 var AddDocumentTabSchema = z2.object({
   documentId: z2.string().min(1, "Document ID is required"),
@@ -3347,38 +3359,41 @@ var toolDefinitions2 = [
   },
   {
     name: "updateGoogleDoc",
-    description: "Update an existing Google Doc",
+    description: "Update an existing Google Doc (replaces all content). For multi-tab docs, specify tabId to replace a single tab's content atomically; leaves other tabs untouched.",
     inputSchema: {
       type: "object",
       properties: {
         documentId: { type: "string", description: "Doc ID" },
-        content: { type: "string", description: "New content" }
+        content: { type: "string", description: "New content" },
+        tabId: { type: "string", description: "Optional. Tab ID to replace (from listDocumentTabs). If set, delete+insert run in a single atomic batchUpdate scoped to that tab." }
       },
       required: ["documentId", "content"]
     }
   },
   {
     name: "insertText",
-    description: "Insert text at a specific index in a Google Doc (surgical edit, doesn't replace entire doc)",
+    description: "Insert text at a specific index in a Google Doc (surgical edit, doesn't replace entire doc). For multi-tab docs, specify tabId to target a specific tab.",
     inputSchema: {
       type: "object",
       properties: {
         documentId: { type: "string", description: "The document ID" },
         text: { type: "string", description: "Text to insert" },
-        index: { type: "number", description: "Position to insert at (1-based)" }
+        index: { type: "number", description: "Position to insert at (1-based)" },
+        tabId: { type: "string", description: "Optional. Tab ID to insert into (from listDocumentTabs). If omitted, inserts into the first/default tab." }
       },
       required: ["documentId", "text", "index"]
     }
   },
   {
     name: "deleteRange",
-    description: "Delete content between start and end indices in a Google Doc",
+    description: "Delete content between start and end indices in a Google Doc. For multi-tab docs, specify tabId to target a specific tab.",
     inputSchema: {
       type: "object",
       properties: {
         documentId: { type: "string", description: "The document ID" },
         startIndex: { type: "number", description: "Start index (1-based, inclusive)" },
-        endIndex: { type: "number", description: "End index (exclusive)" }
+        endIndex: { type: "number", description: "End index (exclusive)" },
+        tabId: { type: "string", description: "Optional. Tab ID to delete from (from listDocumentTabs). If omitted, deletes from the first/default tab." }
       },
       required: ["documentId", "startIndex", "endIndex"]
     }
@@ -3521,7 +3536,7 @@ var toolDefinitions2 = [
   },
   {
     name: "findAndReplaceInDoc",
-    description: "Find and replace text across a Google Document. Dry-run mode counts matches from paragraph text only (may differ from actual replacements which cover tables, headers, footers, etc.)",
+    description: "Find and replace text across a Google Document. Dry-run mode counts matches from paragraph text only (may differ from actual replacements which cover tables, headers, footers, etc.). For multi-tab docs, specify tabId to scope replacements to a single tab.",
     inputSchema: {
       type: "object",
       properties: {
@@ -3529,7 +3544,8 @@ var toolDefinitions2 = [
         findText: { type: "string", description: "Text to find" },
         replaceText: { type: "string", description: "Replacement text" },
         matchCase: { type: "boolean", description: "Case-sensitive match (default: false)" },
-        dryRun: { type: "boolean", description: "Only count approximate matches from paragraph text, do not modify document (default: false)" }
+        dryRun: { type: "boolean", description: "Only count approximate matches from paragraph text, do not modify document (default: false). Ignores tabId \u2014 always scans the full document body." },
+        tabId: { type: "string", description: "Optional. Tab ID to scope replacements to (from listDocumentTabs). If omitted, replaces across all tabs." }
       },
       required: ["documentId", "findText", "replaceText"]
     }
@@ -3843,6 +3859,43 @@ Link: ${doc.webViewLink}` }],
       }
       const a = validation.data;
       const docs = ctx.google.docs({ version: "v1", auth: ctx.authClient });
+      if (a.tabId) {
+        const document2 = await docs.documents.get({ documentId: a.documentId, includeTabsContent: true });
+        const tabs = document2.data.tabs;
+        const tab = tabs ? findTabById(tabs, a.tabId) : null;
+        if (!tab) {
+          return errorResponse(`Tab with ID "${a.tabId}" not found. Use listDocumentTabs to see available tabs.`);
+        }
+        const bodyContent = tab.documentTab?.body?.content;
+        const lastEndIndex = bodyContent?.[bodyContent.length - 1]?.endIndex ?? 1;
+        const deleteEndIndex2 = Math.max(1, lastEndIndex - 1);
+        const requests = [];
+        if (deleteEndIndex2 > 1) {
+          requests.push({
+            deleteContentRange: {
+              range: { startIndex: 1, endIndex: deleteEndIndex2, tabId: a.tabId }
+            }
+          });
+        }
+        requests.push({
+          insertText: { location: { index: 1, tabId: a.tabId }, text: a.content }
+        });
+        requests.push({
+          updateParagraphStyle: {
+            range: { startIndex: 1, endIndex: a.content.length + 1, tabId: a.tabId },
+            paragraphStyle: { namedStyleType: "NORMAL_TEXT" },
+            fields: "namedStyleType"
+          }
+        });
+        await docs.documents.batchUpdate({
+          documentId: a.documentId,
+          requestBody: { requests }
+        });
+        return {
+          content: [{ type: "text", text: `Updated Google Doc: ${document2.data.title} (tab: ${a.tabId})` }],
+          isError: false
+        };
+      }
       const document = await docs.documents.get({ documentId: a.documentId });
       const endIndex = document.data.body?.content?.[document.data.body.content.length - 1]?.endIndex || 1;
       const deleteEndIndex = Math.max(1, endIndex - 1);
@@ -4123,20 +4176,22 @@ Total length: ${totalLength} characters`
         return errorResponse(validation.error.errors[0].message);
       }
       const a = validation.data;
+      const location = { index: a.index };
+      if (a.tabId) location.tabId = a.tabId;
       const docs = ctx.google.docs({ version: "v1", auth: ctx.authClient });
       await docs.documents.batchUpdate({
         documentId: a.documentId,
         requestBody: {
           requests: [{
             insertText: {
-              location: { index: a.index },
+              location,
               text: a.text
             }
           }]
         }
       });
       return {
-        content: [{ type: "text", text: `Successfully inserted ${a.text.length} characters at index ${a.index}` }],
+        content: [{ type: "text", text: `Successfully inserted ${a.text.length} characters at index ${a.index}${a.tabId ? ` in tab ${a.tabId}` : ""}` }],
         isError: false
       };
     }
@@ -4149,22 +4204,22 @@ Total length: ${totalLength} characters`
       if (a.endIndex <= a.startIndex) {
         return errorResponse("endIndex must be greater than startIndex");
       }
+      const range = {
+        startIndex: a.startIndex,
+        endIndex: a.endIndex
+      };
+      if (a.tabId) range.tabId = a.tabId;
       const docs = ctx.google.docs({ version: "v1", auth: ctx.authClient });
       await docs.documents.batchUpdate({
         documentId: a.documentId,
         requestBody: {
           requests: [{
-            deleteContentRange: {
-              range: {
-                startIndex: a.startIndex,
-                endIndex: a.endIndex
-              }
-            }
+            deleteContentRange: { range }
           }]
         }
       });
       return {
-        content: [{ type: "text", text: `Successfully deleted content from index ${a.startIndex} to ${a.endIndex}` }],
+        content: [{ type: "text", text: `Successfully deleted content from index ${a.startIndex} to ${a.endIndex}${a.tabId ? ` in tab ${a.tabId}` : ""}` }],
         isError: false
       };
     }
@@ -4546,25 +4601,20 @@ ${text}`;
           isError: false
         };
       }
+      const replaceAllText = {
+        containsText: { text: a.findText, matchCase: a.matchCase },
+        replaceText: a.replaceText
+      };
+      if (a.tabId) replaceAllText.tabsCriteria = { tabIds: [a.tabId] };
       const response = await docs.documents.batchUpdate({
         documentId: a.documentId,
         requestBody: {
-          requests: [
-            {
-              replaceAllText: {
-                containsText: {
-                  text: a.findText,
-                  matchCase: a.matchCase
-                },
-                replaceText: a.replaceText
-              }
-            }
-          ]
+          requests: [{ replaceAllText }]
         }
       });
       const occurrences = response.data.replies?.[0]?.replaceAllText?.occurrencesChanged ?? 0;
       return {
-        content: [{ type: "text", text: `Replaced ${occurrences} occurrence(s) of "${a.findText}".` }],
+        content: [{ type: "text", text: `Replaced ${occurrences} occurrence(s) of "${a.findText}"${a.tabId ? ` in tab ${a.tabId}` : ""}.` }],
         isError: false
       };
     }
@@ -5008,7 +5058,10 @@ ${index + 1}. ${replyAuthor} (${replyDate})
         });
         parentFolderId = fileInfo.data.parents?.[0];
       }
-      const imageUrl = await uploadImageToDriveHelper(ctx, a.localImagePath, parentFolderId, a.makePublic);
+      const { webContentLink: imageUrl } = await uploadImageToDrive(ctx, a.localImagePath, {
+        parentFolderId,
+        makePublic: a.makePublic
+      });
       await insertInlineImageHelper(ctx, a.documentId, imageUrl, a.index, a.width, a.height);
       return {
         content: [{ type: "text", text: `Successfully uploaded and inserted local image at index ${a.index}
@@ -5133,8 +5186,10 @@ Image URL: ${imageUrl}` }],
       const docs = ctx.google.docs({ version: "v1", auth: ctx.authClient });
       await docs.documents.batchUpdate({
         documentId: a.documentId,
-        // updateDocumentTabProperties is not yet in the googleapis TypeScript types — cast required
-        requestBody: { requests: [{ updateDocumentTabProperties: { tabId: a.tabId, tabProperties: { title: a.title }, fields: "title" } }] }
+        // updateDocumentTabProperties is not yet in the googleapis TypeScript types — cast required.
+        // Per Google Docs API spec: tabId lives INSIDE tabProperties (it's the tab identifier),
+        // and `fields` is a FieldMask for which properties to update (excludes tabId).
+        requestBody: { requests: [{ updateDocumentTabProperties: { tabProperties: { tabId: a.tabId, title: a.title }, fields: "title" } }] }
       });
       return { content: [{ type: "text", text: `Renamed tab ${a.tabId} to "${a.title}".` }], isError: false };
     }
@@ -6629,6 +6684,72 @@ var ExportSlideThumbnailSchema = z4.object({
   mimeType: z4.enum(["PNG", "JPEG"]).optional().default("PNG"),
   size: z4.enum(["SMALL", "MEDIUM", "LARGE"]).optional().default("LARGE")
 });
+var InsertSlidesImageFromUrlSchema = z4.object({
+  presentationId: z4.string().min(1, "Presentation ID is required"),
+  pageObjectId: z4.string().min(1, "Slide/page object ID is required"),
+  imageUrl: z4.string().url("A valid image URL is required"),
+  x: z4.number().optional().default(0),
+  y: z4.number().optional().default(0),
+  width: z4.number().optional(),
+  height: z4.number().optional()
+});
+var MoveSlideElementSchema = z4.object({
+  presentationId: z4.string().min(1, "Presentation ID is required"),
+  objectId: z4.string().min(1, "Element object ID is required"),
+  x: z4.number().optional(),
+  y: z4.number().optional(),
+  width: z4.number().optional(),
+  height: z4.number().optional()
+});
+var DeleteSlideElementSchema = z4.object({
+  presentationId: z4.string().min(1, "Presentation ID is required"),
+  objectId: z4.string().min(1, "Element object ID is required")
+});
+var GetSlideElementInfoSchema = z4.object({
+  presentationId: z4.string().min(1, "Presentation ID is required"),
+  slideObjectId: z4.string().optional()
+});
+var InsertSlidesLocalImageSchema = z4.object({
+  presentationId: z4.string().min(1, "Presentation ID is required"),
+  pageObjectId: z4.string().min(1, "Slide/page object ID is required"),
+  localImagePath: z4.string().min(1, "Local image path is required"),
+  x: z4.number().optional().default(0),
+  y: z4.number().optional().default(0),
+  width: z4.number().optional(),
+  height: z4.number().optional()
+});
+async function insertImageIntoSlide(ctx, presentationId, pageObjectId, imageUrl, x, y, width, height) {
+  const slidesService = ctx.google.slides({ version: "v1", auth: ctx.authClient });
+  const objectId = `img_${uuidv4().substring(0, 8)}`;
+  const elementProperties = {
+    pageObjectId,
+    transform: {
+      scaleX: 1,
+      scaleY: 1,
+      translateX: x,
+      translateY: y,
+      unit: "EMU"
+    }
+  };
+  if (width != null && height != null) {
+    elementProperties.size = {
+      width: { magnitude: width, unit: "EMU" },
+      height: { magnitude: height, unit: "EMU" }
+    };
+  }
+  await slidesService.presentations.batchUpdate({
+    presentationId,
+    requestBody: {
+      requests: [{
+        createImage: { objectId, url: imageUrl, elementProperties }
+      }]
+    }
+  });
+  return {
+    content: [{ type: "text", text: `Inserted image into slide ${pageObjectId} (objectId: ${objectId})` }],
+    isError: false
+  };
+}
 var toolDefinitions4 = [
   {
     name: "createGoogleSlides",
@@ -6942,6 +7063,80 @@ var toolDefinitions4 = [
       },
       required: ["presentationId", "slideObjectId"]
     }
+  },
+  {
+    name: "insertSlidesImageFromUrl",
+    description: "Insert an image into a Google Slides slide from a publicly accessible URL",
+    inputSchema: {
+      type: "object",
+      properties: {
+        presentationId: { type: "string", description: "Presentation ID" },
+        pageObjectId: { type: "string", description: "Slide/page object ID to insert the image into" },
+        imageUrl: { type: "string", description: "Publicly accessible URL of the image" },
+        x: { type: "number", description: "X position in EMU (default: 0)" },
+        y: { type: "number", description: "Y position in EMU (default: 0)" },
+        width: { type: "number", description: "Width in EMU (omit to auto-size)" },
+        height: { type: "number", description: "Height in EMU (omit to auto-size)" }
+      },
+      required: ["presentationId", "pageObjectId", "imageUrl"]
+    }
+  },
+  {
+    name: "getSlideElementInfo",
+    description: "Get position, size, and transform of all elements on a slide. Returns actual rendered bounds.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        presentationId: { type: "string", description: "Presentation ID" },
+        slideObjectId: { type: "string", description: "Slide object ID (omit to get all slides)" }
+      },
+      required: ["presentationId"]
+    }
+  },
+  {
+    name: "moveSlideElement",
+    description: "Move and/or resize an element (image, text box, shape) on a Google Slides slide",
+    inputSchema: {
+      type: "object",
+      properties: {
+        presentationId: { type: "string", description: "Presentation ID" },
+        objectId: { type: "string", description: "Element object ID to move/resize" },
+        x: { type: "number", description: "New X position in EMU" },
+        y: { type: "number", description: "New Y position in EMU" },
+        width: { type: "number", description: "New width in EMU" },
+        height: { type: "number", description: "New height in EMU" }
+      },
+      required: ["presentationId", "objectId"]
+    }
+  },
+  {
+    name: "deleteSlideElement",
+    description: "Delete an element (image, text box, shape) from a Google Slides slide",
+    inputSchema: {
+      type: "object",
+      properties: {
+        presentationId: { type: "string", description: "Presentation ID" },
+        objectId: { type: "string", description: "Element object ID to delete" }
+      },
+      required: ["presentationId", "objectId"]
+    }
+  },
+  {
+    name: "insertSlidesLocalImage",
+    description: "Upload a local image file to Google Drive and insert it into a Google Slides slide",
+    inputSchema: {
+      type: "object",
+      properties: {
+        presentationId: { type: "string", description: "Presentation ID" },
+        pageObjectId: { type: "string", description: "Slide/page object ID to insert the image into" },
+        localImagePath: { type: "string", description: "Absolute path to the local image file" },
+        x: { type: "number", description: "X position in EMU (default: 0)" },
+        y: { type: "number", description: "Y position in EMU (default: 0)" },
+        width: { type: "number", description: "Width in EMU (omit to auto-size)" },
+        height: { type: "number", description: "Height in EMU (omit to auto-size)" }
+      },
+      required: ["presentationId", "pageObjectId", "localImagePath"]
+    }
   }
 ];
 async function handleTool4(toolName, args, ctx) {
@@ -7779,6 +7974,167 @@ Slide ${a.slideIndex ?? index} (ID: ${slide.objectId}):
         isError: false
       };
     }
+    case "getSlideElementInfo": {
+      const validation = GetSlideElementInfoSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const a = validation.data;
+      const slidesService = ctx.google.slides({ version: "v1", auth: ctx.authClient });
+      const sizeOnly = await slidesService.presentations.get({
+        presentationId: a.presentationId,
+        fields: "pageSize"
+      });
+      const slideWidth = sizeOnly.data.pageSize?.width?.magnitude || 9144e3;
+      const slideHeight = sizeOnly.data.pageSize?.height?.magnitude || 6858e3;
+      let slides = [];
+      if (a.slideObjectId) {
+        const page = await slidesService.presentations.pages.get({
+          presentationId: a.presentationId,
+          pageObjectId: a.slideObjectId,
+          fields: "objectId,pageElements(objectId,transform,size,shape/shapeType,image)"
+        });
+        slides = [page.data];
+      } else {
+        const withSlides = await slidesService.presentations.get({
+          presentationId: a.presentationId,
+          fields: "slides(objectId,pageElements(objectId,transform,size,shape/shapeType,image))"
+        });
+        slides = withSlides.data.slides || [];
+      }
+      const lines = [`Slide dimensions: ${slideWidth} x ${slideHeight} EMU`];
+      for (const slide of slides) {
+        lines.push(`
+--- Slide: ${slide.objectId} ---`);
+        for (const el of slide.pageElements || []) {
+          const t = el.transform || {};
+          const s = el.size || {};
+          const intrW = s.width?.magnitude || 0;
+          const intrH = s.height?.magnitude || 0;
+          const scX = t.scaleX || 1;
+          const scY = t.scaleY || 1;
+          const tx = t.translateX || 0;
+          const ty = t.translateY || 0;
+          const renderedW = intrW * scX;
+          const renderedH = intrH * scY;
+          const right = tx + renderedW;
+          const bottom = ty + renderedH;
+          const offPage = tx < 0 || ty < 0 || right > slideWidth || bottom > slideHeight ? " *** OFF PAGE ***" : "";
+          lines.push(`  ${el.objectId} (${el.shape ? "shape:" + el.shape.shapeType : el.image ? "image" : "other"})`);
+          lines.push(`    intrinsic: ${intrW} x ${intrH}, scale: ${scX} x ${scY}`);
+          lines.push(`    rendered: ${Math.round(renderedW)} x ${Math.round(renderedH)} at (${tx}, ${ty})`);
+          lines.push(`    bounds: right=${Math.round(right)}, bottom=${Math.round(bottom)}${offPage}`);
+        }
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }], isError: false };
+    }
+    case "moveSlideElement": {
+      const validation = MoveSlideElementSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const a = validation.data;
+      const slidesService = ctx.google.slides({ version: "v1", auth: ctx.authClient });
+      const pres = await slidesService.presentations.get({
+        presentationId: a.presentationId,
+        fields: "slides(pageElements(objectId,transform,size))"
+      });
+      let currentTransform = null;
+      let currentSize = null;
+      for (const slide of pres.data.slides || []) {
+        for (const el of slide.pageElements || []) {
+          if (el.objectId === a.objectId) {
+            currentTransform = el.transform || null;
+            currentSize = el.size || null;
+            break;
+          }
+        }
+        if (currentTransform) break;
+      }
+      if (!currentTransform) {
+        return errorResponse(`Element ${a.objectId} not found in presentation`);
+      }
+      const origWidth = currentSize?.width?.magnitude || 3e6;
+      const origHeight = currentSize?.height?.magnitude || 3e6;
+      const curScaleX = currentTransform.scaleX || 1;
+      const curScaleY = currentTransform.scaleY || 1;
+      const newScaleX = a.width !== void 0 ? a.width / origWidth : curScaleX;
+      const newScaleY = a.height !== void 0 ? a.height / origHeight : curScaleY;
+      const newX = a.x ?? (currentTransform.translateX || 0);
+      const newY = a.y ?? (currentTransform.translateY || 0);
+      const newTransform = {
+        scaleX: newScaleX,
+        scaleY: newScaleY,
+        translateX: newX,
+        translateY: newY,
+        shearX: currentTransform.shearX || 0,
+        shearY: currentTransform.shearY || 0,
+        unit: "EMU"
+      };
+      const requests = [{
+        updatePageElementTransform: {
+          objectId: a.objectId,
+          applyMode: "ABSOLUTE",
+          transform: newTransform
+        }
+      }];
+      await slidesService.presentations.batchUpdate({
+        presentationId: a.presentationId,
+        requestBody: { requests }
+      });
+      const didResize = a.width !== void 0 || a.height !== void 0;
+      const action = didResize ? "Moved/resized" : "Moved";
+      return {
+        content: [{ type: "text", text: `${action} element ${a.objectId} to (${newX}, ${newY})` }],
+        isError: false
+      };
+    }
+    case "deleteSlideElement": {
+      const validation = DeleteSlideElementSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const a = validation.data;
+      const slidesService = ctx.google.slides({ version: "v1", auth: ctx.authClient });
+      await slidesService.presentations.batchUpdate({
+        presentationId: a.presentationId,
+        requestBody: {
+          requests: [{ deleteObject: { objectId: a.objectId } }]
+        }
+      });
+      return {
+        content: [{ type: "text", text: `Deleted element ${a.objectId}` }],
+        isError: false
+      };
+    }
+    case "insertSlidesImageFromUrl": {
+      const validation = InsertSlidesImageFromUrlSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const a = validation.data;
+      return insertImageIntoSlide(ctx, a.presentationId, a.pageObjectId, a.imageUrl, a.x, a.y, a.width, a.height);
+    }
+    case "insertSlidesLocalImage": {
+      const validation = InsertSlidesLocalImageSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const a = validation.data;
+      const { fileId, webContentLink } = await uploadImageToDrive(ctx, a.localImagePath, {
+        makePublic: true
+      });
+      try {
+        const result = await insertImageIntoSlide(
+          ctx,
+          a.presentationId,
+          a.pageObjectId,
+          webContentLink,
+          a.x,
+          a.y,
+          a.width,
+          a.height
+        );
+        await deleteDriveFile(ctx, fileId).catch(
+          (err) => ctx.log(`insertSlidesLocalImage: failed to delete intermediary Drive file ${fileId}`, err)
+        );
+        return result;
+      } catch (err) {
+        await deleteDriveFile(ctx, fileId).catch(() => {
+        });
+        throw err;
+      }
+    }
     default:
       return null;
   }
@@ -8513,6 +8869,7 @@ Examples:
 Environment Variables:
   GOOGLE_DRIVE_OAUTH_CREDENTIALS        Path to OAuth credentials file
   GOOGLE_DRIVE_MCP_TOKEN_PATH           Path to store authentication tokens
+  GOOGLE_DRIVE_MCP_AUTH_PORT            Starting port for OAuth callback server (default: 3000, uses 5 consecutive ports)
 
   Transport Configuration:
   MCP_TRANSPORT                         Transport mode: stdio or http (default: stdio)
@@ -8538,8 +8895,9 @@ async function runAuthServer() {
     const authServerInstance = new AuthServer(oauth2Client);
     const success = await authServerInstance.start(true);
     if (!success && !authServerInstance.authCompletedSuccessfully) {
+      const { start, end } = authServerInstance.portRange;
       console.error(
-        "Authentication failed. Could not start server or validate existing tokens. Check port availability (3000-3004) and try again."
+        `Authentication failed. Could not start server or validate existing tokens. Check port availability (${start}-${end}) and try again.`
       );
       process.exit(1);
     } else if (authServerInstance.authCompletedSuccessfully) {