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

package/dist/index.js

@@ -2555,9 +2555,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 +2906,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;
@@ -5008,7 +5003,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}
@@ -6629,6 +6627,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 +7006,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 +7917,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;
   }