@piotr-agier/google-drive-mcp 1.5.0 → 1.6.0

package/README.md

@@ -402,6 +402,24 @@ Add the server to your Claude Desktop configuration:
   - `exportMimeType`: For Google Workspace files, MIME type to export as (optional, e.g., 'application/pdf', 'text/csv')
   - `overwrite`: Whether to overwrite existing files (optional, default: false)
 
+#### PDF Ingestion and Conversion (v1.6.0)
+- **convertPdfToGoogleDoc** - Convert a PDF already stored in Drive into an editable Google Doc
+  - `fileId`: Source PDF file ID
+  - `newName`: Optional destination doc name
+  - `parentFolderId`: Optional destination folder
+
+- **bulkConvertFolderPdfs** - Convert all PDFs in a folder and return per-file success/failure summary
+  - `folderId`: Source folder ID
+  - `maxResults`: Maximum PDFs to process (optional, default: 100)
+  - `continueOnError`: Continue processing after individual failures (optional, default: true)
+
+- **uploadPdfWithSplit** - Upload a local PDF, optionally split into chunked PDF parts before upload
+  - `localPath`: Absolute local path to PDF
+  - `split`: Enable split mode metadata output (optional, default: false)
+  - `maxPagesPerChunk`: Advisory chunk size for split planning (optional)
+  - `parentFolderId`: Optional destination folder
+  - `namePrefix`: Optional uploaded file name prefix
+
 ### Folder Operations
 - **createFolder** - Create a new folder
   - `name`: Folder name
@@ -433,6 +451,24 @@ Add the server to your Claude Desktop configuration:
   - `documentId`: Document ID
   - `includeContent`: Include content summary (character count) for each tab (optional)
 
+- **addDocumentTab** - Add a new tab in a Google Doc
+  - `documentId`: Document ID
+  - `title`: Tab title
+
+- **renameDocumentTab** - Rename an existing tab in a Google Doc
+  - `documentId`: Document ID
+  - `tabId`: Tab ID
+  - `title`: New tab title
+
+- **insertSmartChip** - Insert a person smart chip (mention) at a document index. Only person chips are supported by the Docs API; date and file chips are read-only.
+  - `documentId`: Document ID
+  - `index`: Insertion index (1-based)
+  - `chipType`: `person` (only supported type)
+  - `personEmail`: Email address for the person mention
+
+- **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
+
 - **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)

package/dist/index.js

@@ -609,7 +609,7 @@ async function authenticate() {
 // src/index.ts
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { readFileSync } from "fs";
-import { join as join3, dirname as dirname4 } from "path";
+import { join as join4, dirname as dirname4 } from "path";
 
 // src/utils.ts
 function buildCalendarEventUpdate(existing, overrides) {
@@ -690,6 +690,10 @@ __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 } from "fs/promises";
+import { tmpdir } from "os";
+import { basename as basename2, extname as extname2, join as join3 } from "path";
+import { PDFDocument } from "pdf-lib";
 
 // src/download-file.ts
 import { createWriteStream, existsSync, renameSync, statSync, unlinkSync } from "fs";
@@ -986,6 +990,44 @@ var ShareFileSchema = z.object({
   role: z.enum(["writer", "commenter", "reader"]).default("reader"),
   sendNotificationEmail: z.boolean().optional().default(true)
 });
+var ConvertPdfToGoogleDocSchema = z.object({
+  fileId: z.string().min(1, "File ID is required"),
+  newName: z.string().optional(),
+  parentFolderId: z.string().optional()
+});
+var BulkConvertFolderPdfsSchema = z.object({
+  folderId: z.string().min(1, "Folder ID is required"),
+  maxResults: z.number().int().min(1).max(200).optional().default(100),
+  continueOnError: z.boolean().optional().default(true)
+});
+var UploadPdfWithSplitSchema = z.object({
+  localPath: z.string().min(1, "Local file path is required"),
+  split: z.boolean().optional().default(false),
+  maxPagesPerChunk: z.number().int().min(1).max(500).optional(),
+  parentFolderId: z.string().optional(),
+  namePrefix: z.string().optional()
+});
+async function splitPdfIntoChunkFiles(localPath, maxPagesPerChunk) {
+  const sourceBytes = await readFile3(localPath);
+  const source = await PDFDocument.load(sourceBytes);
+  const pageCount = source.getPageCount();
+  if (pageCount === 0) {
+    throw new Error("PDF contains no pages.");
+  }
+  const tempDir = await mkdtemp(join3(tmpdir(), "gdrive-mcp-split-"));
+  const files = [];
+  for (let start = 0, part = 1; start < pageCount; start += maxPagesPerChunk, part++) {
+    const end = Math.min(start + maxPagesPerChunk, pageCount);
+    const chunkDoc = await PDFDocument.create();
+    const pages = await chunkDoc.copyPages(source, Array.from({ length: end - start }, (_, i) => start + i));
+    for (const page of pages) chunkDoc.addPage(page);
+    const chunkBytes = await chunkDoc.save();
+    const chunkPath = join3(tempDir, `part-${part}.pdf`);
+    await writeFile2(chunkPath, chunkBytes);
+    files.push(chunkPath);
+  }
+  return { tempDir, files };
+}
 var toolDefinitions = [
   {
     name: "search",
@@ -1208,6 +1250,47 @@ var toolDefinitions = [
       },
       required: ["fileId", "emailAddress"]
     }
+  },
+  {
+    name: "convertPdfToGoogleDoc",
+    description: "Convert an existing PDF in Drive into an editable Google Doc",
+    inputSchema: {
+      type: "object",
+      properties: {
+        fileId: { type: "string", description: "PDF file ID in Google Drive" },
+        newName: { type: "string", description: "Optional name for converted Doc" },
+        parentFolderId: { type: "string", description: "Optional destination folder ID" }
+      },
+      required: ["fileId"]
+    }
+  },
+  {
+    name: "bulkConvertFolderPdfs",
+    description: "Convert all PDFs in a folder into Google Docs and return per-file results",
+    inputSchema: {
+      type: "object",
+      properties: {
+        folderId: { type: "string", description: "Folder ID containing PDFs" },
+        maxResults: { type: "number", description: "Maximum PDFs to process (1-200, default: 100)" },
+        continueOnError: { type: "boolean", description: "Continue conversion when one file fails (default: true)" }
+      },
+      required: ["folderId"]
+    }
+  },
+  {
+    name: "uploadPdfWithSplit",
+    description: "Upload PDF and optionally split into chunked parts (metadata split plan for now)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        localPath: { type: "string", description: "Absolute path to local PDF" },
+        split: { type: "boolean", description: "Enable split mode" },
+        maxPagesPerChunk: { type: "number", description: "Target max pages per chunk (advisory metadata)" },
+        parentFolderId: { type: "string", description: "Optional destination folder ID" },
+        namePrefix: { type: "string", description: "Optional output name prefix" }
+      },
+      required: ["localPath"]
+    }
   }
 ];
 async function handleTool(toolName, args, ctx) {
@@ -1712,6 +1795,127 @@ ${lines.join("\n")}` }], isError: false };
         isError: false
       };
     }
+    case "convertPdfToGoogleDoc": {
+      const validation = ConvertPdfToGoogleDocSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const data = validation.data;
+      const source = await ctx.getDrive().files.get({
+        fileId: data.fileId,
+        fields: "id,name,mimeType,parents",
+        supportsAllDrives: true
+      });
+      if (source.data.mimeType !== "application/pdf") {
+        return errorResponse(`File ${data.fileId} is not a PDF (mimeType=${source.data.mimeType || "unknown"})`);
+      }
+      const parentId = data.parentFolderId || source.data.parents?.[0];
+      const converted = await ctx.getDrive().files.copy({
+        fileId: data.fileId,
+        requestBody: {
+          name: data.newName || `${source.data.name || "Converted PDF"} (Doc)`,
+          mimeType: "application/vnd.google-apps.document",
+          ...parentId ? { parents: [parentId] } : {}
+        },
+        fields: "id,name,webViewLink,mimeType",
+        supportsAllDrives: true
+      });
+      return { content: [{ type: "text", text: `Converted PDF to Google Doc: ${converted.data.name}
+ID: ${converted.data.id}
+Link: ${converted.data.webViewLink}` }], isError: false };
+    }
+    case "bulkConvertFolderPdfs": {
+      const validation = BulkConvertFolderPdfsSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const data = validation.data;
+      const list = await ctx.getDrive().files.list({
+        q: `'${escapeDriveQuery(data.folderId)}' in parents and mimeType='application/pdf' and trashed=false`,
+        pageSize: data.maxResults,
+        fields: "files(id,name,mimeType)",
+        includeItemsFromAllDrives: true,
+        supportsAllDrives: true
+      });
+      const files = list.data.files || [];
+      const results = [];
+      for (const f of files) {
+        try {
+          const converted = await ctx.getDrive().files.copy({
+            fileId: f.id,
+            requestBody: {
+              name: `${f.name || "Converted PDF"} (Doc)`,
+              mimeType: "application/vnd.google-apps.document",
+              parents: [data.folderId]
+            },
+            fields: "id,name",
+            supportsAllDrives: true
+          });
+          results.push({ id: f.id || void 0, name: f.name || void 0, docId: converted.data.id || void 0, ok: true });
+        } catch (err) {
+          const message = err?.message || "Unknown conversion error";
+          results.push({ id: f.id || void 0, name: f.name || void 0, ok: false, error: message });
+          if (!data.continueOnError) break;
+        }
+      }
+      const ok = results.filter((r) => r.ok).length;
+      const fail = results.length - ok;
+      return {
+        content: [{ type: "text", text: `Bulk PDF conversion finished. Processed=${results.length}, Success=${ok}, Failed=${fail}
+
+${results.map((r) => r.ok ? `\u2705 ${r.name} -> ${r.docId}` : `\u274C ${r.name}: ${r.error}`).join("\n")}` }],
+        isError: false
+      };
+    }
+    case "uploadPdfWithSplit": {
+      const validation = UploadPdfWithSplitSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const data = validation.data;
+      if (!existsSync2(data.localPath)) return errorResponse(`File not found: ${data.localPath}`);
+      const parentId = await ctx.resolveFolderId(data.parentFolderId);
+      if (!data.split) {
+        const fileName = data.namePrefix || data.localPath.split(/[\\/]/).pop() || "upload.pdf";
+        const uploaded = await ctx.getDrive().files.create({
+          requestBody: { name: fileName, parents: [parentId] },
+          media: { mimeType: "application/pdf", body: createReadStream(data.localPath) },
+          fields: "id,name,webViewLink",
+          supportsAllDrives: true
+        });
+        return {
+          content: [{ type: "text", text: `Uploaded PDF without split: ${uploaded.data.name}
+ID: ${uploaded.data.id}` }],
+          isError: false
+        };
+      }
+      const maxPagesPerChunk = data.maxPagesPerChunk ?? 25;
+      const baseName = data.namePrefix || basename2(data.localPath, extname2(data.localPath));
+      let tempDir;
+      try {
+        const splitResult = await splitPdfIntoChunkFiles(data.localPath, maxPagesPerChunk);
+        tempDir = splitResult.tempDir;
+        const uploadedParts = [];
+        for (let i = 0; i < splitResult.files.length; i++) {
+          const partPath = splitResult.files[i];
+          const partName = `${baseName}-part-${i + 1}.pdf`;
+          const uploaded = await ctx.getDrive().files.create({
+            requestBody: { name: partName, parents: [parentId] },
+            media: { mimeType: "application/pdf", body: createReadStream(partPath) },
+            fields: "id,name,webViewLink",
+            supportsAllDrives: true
+          });
+          uploadedParts.push({ id: uploaded.data.id, name: uploaded.data.name });
+        }
+        const lines = uploadedParts.map((p, idx) => `- part ${idx + 1}: ${p.name} (ID: ${p.id})`);
+        return {
+          content: [{
+            type: "text",
+            text: `Uploaded split PDF into ${uploadedParts.length} part(s) using maxPagesPerChunk=${maxPagesPerChunk}
+${lines.join("\n")}`
+          }],
+          isError: false
+        };
+      } finally {
+        if (tempDir) {
+          await rm(tempDir, { recursive: true, force: true });
+        }
+      }
+    }
     default:
       return null;
   }
@@ -1725,7 +1929,7 @@ __export(docs_exports, {
 });
 import { z as z2 } from "zod";
 import { createReadStream as createReadStream2, existsSync as existsSync3 } from "fs";
-import { basename as basename2, extname as extname2 } from "path";
+import { basename as basename3, extname as extname3 } from "path";
 function hexToRgbColor(hex) {
   if (!hex) return null;
   let hexClean = hex.startsWith("#") ? hex.slice(1) : hex;
@@ -2003,7 +2207,7 @@ async function uploadImageToDriveHelper(ctx, localFilePath, parentFolderId, make
   if (!existsSync3(localFilePath)) {
     throw new Error(`Image file not found: ${localFilePath}`);
   }
-  const fileName = basename2(localFilePath);
+  const fileName = basename3(localFilePath);
   const mimeTypeMap = {
     ".jpg": "image/jpeg",
     ".jpeg": "image/jpeg",
@@ -2013,7 +2217,7 @@ async function uploadImageToDriveHelper(ctx, localFilePath, parentFolderId, make
     ".webp": "image/webp",
     ".svg": "image/svg+xml"
   };
-  const ext = extname2(localFilePath).toLowerCase();
+  const ext = extname3(localFilePath).toLowerCase();
   const mimeType = mimeTypeMap[ext] || "application/octet-stream";
   const fileMetadata = {
     name: fileName,
@@ -2197,6 +2401,24 @@ var FindAndReplaceInDocSchema = z2.object({
   matchCase: z2.boolean().optional().default(false),
   dryRun: z2.boolean().optional().default(false)
 });
+var AddDocumentTabSchema = z2.object({
+  documentId: z2.string().min(1, "Document ID is required"),
+  title: z2.string().min(1, "Tab title is required")
+});
+var RenameDocumentTabSchema = z2.object({
+  documentId: z2.string().min(1, "Document ID is required"),
+  tabId: z2.string().min(1, "Tab ID is required"),
+  title: z2.string().min(1, "Tab title is required")
+});
+var InsertSmartChipSchema = z2.object({
+  documentId: z2.string().min(1, "Document ID is required"),
+  index: z2.number().int().min(1, "Index must be at least 1"),
+  chipType: z2.enum(["person"]),
+  personEmail: z2.string().email("Valid email is required for person chip")
+});
+var ReadSmartChipsSchema = z2.object({
+  documentId: z2.string().min(1, "Document ID is required")
+});
 var toolDefinitions2 = [
   {
     name: "createGoogleDoc",
@@ -2549,6 +2771,56 @@ var toolDefinitions2 = [
       },
       required: ["documentId"]
     }
+  },
+  {
+    name: "addDocumentTab",
+    description: "Add a new tab in a Google Doc",
+    inputSchema: {
+      type: "object",
+      properties: {
+        documentId: { type: "string", description: "Document ID" },
+        title: { type: "string", description: "Tab title" }
+      },
+      required: ["documentId", "title"]
+    }
+  },
+  {
+    name: "renameDocumentTab",
+    description: "Rename an existing Google Doc tab",
+    inputSchema: {
+      type: "object",
+      properties: {
+        documentId: { type: "string", description: "Document ID" },
+        tabId: { type: "string", description: "Tab ID" },
+        title: { type: "string", description: "New tab title" }
+      },
+      required: ["documentId", "tabId", "title"]
+    }
+  },
+  {
+    name: "insertSmartChip",
+    description: "Insert a person smart chip (mention) at a document index. Only person chips are supported by the Docs API; date and file chips are read-only.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        documentId: { type: "string", description: "Document ID" },
+        index: { type: "number", description: "Insertion index (1-based)" },
+        chipType: { type: "string", enum: ["person"], description: "Smart chip type (only 'person' is supported)" },
+        personEmail: { type: "string", description: "Email address for the person mention" }
+      },
+      required: ["documentId", "index", "chipType", "personEmail"]
+    }
+  },
+  {
+    name: "readSmartChips",
+    description: "Read smart chip-like elements (person mentions, rich links, date chips) from the default tab of a document",
+    inputSchema: {
+      type: "object",
+      properties: {
+        documentId: { type: "string", description: "Document ID" }
+      },
+      required: ["documentId"]
+    }
   }
 ];
 async function handleTool2(toolName, args, ctx) {
@@ -3660,6 +3932,65 @@ Image URL: ${imageUrl}` }],
 `;
       return { content: [{ type: "text", text: result }], isError: false };
     }
+    case "addDocumentTab": {
+      const validation = AddDocumentTabSchema.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 });
+      await docs.documents.batchUpdate({
+        documentId: a.documentId,
+        // createTab is not yet in the googleapis TypeScript types — cast required
+        requestBody: { requests: [{ createTab: { tabProperties: { title: a.title } } }] }
+      });
+      return { content: [{ type: "text", text: `Requested creation of tab "${a.title}" in document ${a.documentId}.` }], isError: false };
+    }
+    case "renameDocumentTab": {
+      const validation = RenameDocumentTabSchema.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 });
+      await docs.documents.batchUpdate({
+        documentId: a.documentId,
+        // updateTabProperties is not yet in the googleapis TypeScript types — cast required
+        requestBody: { requests: [{ updateTabProperties: { tabId: a.tabId, tabProperties: { title: a.title }, fields: "title" } }] }
+      });
+      return { content: [{ type: "text", text: `Renamed tab ${a.tabId} to "${a.title}".` }], isError: false };
+    }
+    case "insertSmartChip": {
+      const validation = InsertSmartChipSchema.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 });
+      await docs.documents.batchUpdate({
+        documentId: a.documentId,
+        requestBody: {
+          requests: [{
+            insertPerson: {
+              personProperties: { email: a.personEmail },
+              location: { index: a.index }
+            }
+            // insertPerson is not yet in the googleapis TypeScript types — cast required
+          }]
+        }
+      });
+      return { content: [{ type: "text", text: `Inserted person smart chip for ${a.personEmail} at index ${a.index}.` }], isError: false };
+    }
+    case "readSmartChips": {
+      const validation = ReadSmartChipsSchema.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 doc = await docs.documents.get({ documentId: a.documentId });
+      const body = doc.data.body?.content || [];
+      const hits = [];
+      for (const block of body) {
+        for (const el of block?.paragraph?.elements || []) {
+          if (el?.richLink) hits.push(`richLink: ${el.richLink.richLinkProperties?.uri || "unknown"}`);
+          if (el?.person) hits.push(`person: ${el.person.personProperties?.email || "unknown"}`);
+        }
+      }
+      return { content: [{ type: "text", text: hits.length ? hits.join("\n") : "No smart chips detected (note: only the default tab is scanned)." }], isError: false };
+    }
     default:
       return null;
   }
@@ -6677,7 +7008,7 @@ var authClient = null;
 var authenticationPromise = null;
 var __filename = fileURLToPath2(import.meta.url);
 var __dirname = dirname4(__filename);
-var packageJsonPath = join3(__dirname, "..", "package.json");
+var packageJsonPath = join4(__dirname, "..", "package.json");
 var packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
 var VERSION = packageJson.version;
 function log(message, data) {