mcp-google-gdrive 0.1.0

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "mcp-google-gdrive",
+  "version": "0.1.0",
+  "description": "MCP server for Google Drive API with full file management and Workspace format conversion",
+  "type": "module",
+  "bin": {
+    "mcp-google-gdrive": "./src/index.js"
+  },
+  "main": "./src/index.js",
+  "scripts": {
+    "start": "node src/index.js",
+    "auth": "node src/index.js --auth"
+  },
+  "keywords": [
+    "mcp",
+    "google-drive",
+    "google-workspace",
+    "file-management"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sleepytimeshon/mcp-google-gdrive.git"
+  },
+  "homepage": "https://github.com/sleepytimeshon/mcp-google-gdrive#readme",
+  "bugs": {
+    "url": "https://github.com/sleepytimeshon/mcp-google-gdrive/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "googleapis": "^144.0.0",
+    "turndown": "^7.2.0",
+    "zod": "^3.25.0"
+  }
+}

package/src/index.js

@@ -0,0 +1,487 @@
+#!/usr/bin/env node
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { google } from "googleapis";
+import TurndownService from "turndown";
+import { readFile, writeFile, mkdir, chmod } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { createInterface } from "node:readline";
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const SCOPES = ["https://www.googleapis.com/auth/drive"];
+const CONFIG_DIR = join(homedir(), ".config", "mcp-google-gdrive");
+const CREDENTIALS_PATH = join(CONFIG_DIR, "credentials.json");
+const TOKEN_PATH = join(CONFIG_DIR, "token.json");
+const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+
+const DRIVE_ID_REGEX = /^[a-zA-Z0-9_-]+$/;
+
+const turndown = new TurndownService({
+  headingStyle: "atx",
+  codeBlockStyle: "fenced",
+  bulletListMarker: "-",
+  emDelimiter: "_",
+  strongDelimiter: "**",
+});
+
+// ─── Auth ────────────────────────────────────────────────────────────────────
+
+let authClient = null;
+let driveClient = null;
+
+async function ensureConfigDir() {
+  await mkdir(CONFIG_DIR, { recursive: true });
+}
+
+async function loadCredentials() {
+  try {
+    const content = await readFile(CREDENTIALS_PATH, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new Error(
+        `credentials.json not found at ${CREDENTIALS_PATH}\n` +
+        "Setup instructions:\n" +
+        "1. Go to https://console.cloud.google.com/\n" +
+        "2. Create a project and enable the Google Drive API\n" +
+        "3. Create OAuth2 desktop credentials\n" +
+        "4. Download the JSON and save it to:\n" +
+        `   ${CREDENTIALS_PATH}`
+      );
+    }
+    throw err;
+  }
+}
+
+async function loadToken() {
+  try {
+    const content = await readFile(TOKEN_PATH, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+
+async function saveToken(token) {
+  await writeFile(TOKEN_PATH, JSON.stringify(token, null, 2));
+  await chmod(TOKEN_PATH, 0o600);
+}
+
+async function authorize() {
+  await ensureConfigDir();
+  const credentials = await loadCredentials();
+
+  const { client_id, client_secret, redirect_uris } =
+    credentials.installed || credentials.web;
+
+  const oauth2Client = new google.auth.OAuth2(
+    client_id,
+    client_secret,
+    redirect_uris?.[0] || "urn:ietf:wg:oauth:2.0:oob"
+  );
+
+  // Try loading existing token
+  const token = await loadToken();
+  if (!token) {
+    throw new Error(
+      `No token.json found. Run first-time authorization:\n` +
+      `  node src/index.js --auth\n\n` +
+      `This must be done before starting the MCP server.`
+    );
+  }
+
+  oauth2Client.setCredentials(token);
+
+  // Auto-save on token refresh
+  oauth2Client.on("tokens", async (newTokens) => {
+    try {
+      const existing = await loadToken();
+      const merged = { ...existing, ...newTokens };
+      await saveToken(merged);
+    } catch (err) {
+      process.stderr.write(`Warning: Failed to save refreshed token: ${err.message}\n`);
+    }
+  });
+
+  return oauth2Client;
+}
+
+async function interactiveAuth() {
+  await ensureConfigDir();
+  const credentials = await loadCredentials();
+
+  const { client_id, client_secret, redirect_uris } =
+    credentials.installed || credentials.web;
+
+  const oauth2Client = new google.auth.OAuth2(
+    client_id,
+    client_secret,
+    redirect_uris?.[0] || "urn:ietf:wg:oauth:2.0:oob"
+  );
+
+  const authUrl = oauth2Client.generateAuthUrl({
+    access_type: "offline",
+    scope: SCOPES,
+    prompt: "consent",
+  });
+
+  process.stderr.write("\n═══ Google Drive MCP — First-Run Authorization ═══\n\n");
+  process.stderr.write("Open this URL in your browser:\n\n");
+  process.stderr.write(`  ${authUrl}\n\n`);
+  process.stderr.write("After granting access, paste the authorization code below.\n\n");
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
+
+  const code = await new Promise((resolve) => {
+    rl.question("Authorization code: ", (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+
+  const { tokens } = await oauth2Client.getToken(code);
+  await saveToken(tokens);
+
+  process.stderr.write("\nAuthorization successful! Token saved.\n");
+  process.stderr.write(`Token stored at: ${TOKEN_PATH}\n\n`);
+}
+
+function getDrive() {
+  if (!driveClient) throw new Error("Drive client not initialized. Auth may have failed.");
+  return driveClient;
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function jsonResponse(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+
+function textResponse(text) {
+  return { content: [{ type: "text", text }] };
+}
+
+function errorResponse(message) {
+  return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+}
+
+const FILE_FIELDS = "id,name,mimeType,size,createdTime,modifiedTime,parents,webViewLink,owners,shared,description";
+const LIST_FIELDS = "id,name,mimeType,modifiedTime,size,parents";
+
+// ─── Server ──────────────────────────────────────────────────────────────────
+
+const server = new McpServer({
+  name: "mcp-google-gdrive",
+  version: "0.1.0",
+});
+
+// ─── Tool: gdrive_list_files ─────────────────────────────────────────────────
+
+server.registerTool(
+  "gdrive_list_files",
+  {
+    description:
+      "List files in Google Drive with optional search query and folder filtering. " +
+      "Use the query parameter for Drive search syntax (e.g., \"name contains 'report'\", " +
+      "\"mimeType = 'application/pdf'\"). Use folderId to list contents of a specific folder.",
+    inputSchema: {
+      query: z.string().optional().describe("Drive search query (e.g., \"name contains 'report'\")"),
+      folderId: z.string().regex(/^[a-zA-Z0-9_-]+$/, "Invalid folder ID format").optional().describe("List files in this folder only"),
+      pageSize: z.number().optional().default(20).describe("Results per page (max 100)"),
+      pageToken: z.string().optional().describe("Token for next page of results"),
+      orderBy: z.string().optional().default("modifiedTime desc").describe("Sort order"),
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true,
+    },
+  },
+  async ({ query, folderId, pageSize, pageToken, orderBy }) => {
+    try {
+      const drive = await getDrive();
+
+      let q = "trashed = false";
+      if (folderId) q += ` and '${folderId}' in parents`;
+      if (query) q += ` and ${query}`;
+
+      const res = await drive.files.list({
+        q,
+        pageSize: Math.min(pageSize || 20, 100),
+        pageToken: pageToken || undefined,
+        orderBy: orderBy || "modifiedTime desc",
+        fields: `nextPageToken,files(${LIST_FIELDS})`,
+      });
+
+      return jsonResponse({
+        files: res.data.files || [],
+        nextPageToken: res.data.nextPageToken || null,
+        resultCount: (res.data.files || []).length,
+      });
+    } catch (err) {
+      return errorResponse(err.message);
+    }
+  }
+);
+
+// ─── Tool: gdrive_get_metadata ───────────────────────────────────────────────
+
+server.registerTool(
+  "gdrive_get_metadata",
+  {
+    description:
+      "Get detailed metadata for a specific file in Google Drive by its file ID. " +
+      "Returns name, type, size, dates, parents, web link, and sharing status.",
+    inputSchema: {
+      fileId: z.string().describe("Google Drive file ID"),
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true,
+    },
+  },
+  async ({ fileId }) => {
+    try {
+      const drive = await getDrive();
+      const res = await drive.files.get({
+        fileId,
+        fields: FILE_FIELDS,
+      });
+      return jsonResponse(res.data);
+    } catch (err) {
+      if (err.code === 404) {
+        return errorResponse(`File not found: ${fileId}. Verify the file ID exists and you have access.`);
+      }
+      return errorResponse(err.message);
+    }
+  }
+);
+
+// ─── Tool: gdrive_read_file ─────────────────────────────────────────────────
+
+server.registerTool(
+  "gdrive_read_file",
+  {
+    description:
+      "Read the content of a file from Google Drive. Automatically detects Google Workspace types: " +
+      "Docs are exported as Markdown, Sheets as CSV, Slides as plain text. " +
+      "Binary files under 10MB are returned as base64. Files over 10MB return metadata only.",
+    inputSchema: {
+      fileId: z.string().describe("Google Drive file ID"),
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true,
+    },
+  },
+  async ({ fileId }) => {
+    try {
+      const drive = await getDrive();
+
+      // Get file metadata first
+      const meta = await drive.files.get({
+        fileId,
+        fields: "id,name,mimeType,size,webViewLink",
+      });
+
+      const { mimeType, name, size } = meta.data;
+
+      // Google Workspace types — export
+      if (mimeType === "application/vnd.google-apps.document") {
+        const res = await drive.files.export({
+          fileId,
+          mimeType: "text/html",
+        }, { responseType: "text" });
+        const markdown = turndown.turndown(res.data);
+        return textResponse(markdown);
+      }
+
+      if (mimeType === "application/vnd.google-apps.spreadsheet") {
+        const res = await drive.files.export({
+          fileId,
+          mimeType: "text/csv",
+        }, { responseType: "text" });
+        return textResponse(res.data);
+      }
+
+      if (mimeType === "application/vnd.google-apps.presentation") {
+        const res = await drive.files.export({
+          fileId,
+          mimeType: "text/plain",
+        }, { responseType: "text" });
+        return textResponse(res.data);
+      }
+
+      if (mimeType === "application/vnd.google-apps.drawing") {
+        return textResponse(`[Google Drawing: ${name}] — Export not supported in read_file. Use export tools.`);
+      }
+
+      if (mimeType && mimeType.startsWith("application/vnd.google-apps.")) {
+        return errorResponse(`Cannot read Google Workspace type: ${mimeType}. File: ${name}`);
+      }
+
+      // Regular files — check size
+      const fileSize = parseInt(size, 10) || 0;
+      if (fileSize > MAX_FILE_SIZE) {
+        return jsonResponse({
+          warning: "File exceeds 10MB limit. Returning metadata only.",
+          name,
+          mimeType,
+          size: fileSize,
+          sizeFormatted: `${(fileSize / (1024 * 1024)).toFixed(1)} MB`,
+          webViewLink: meta.data.webViewLink,
+        });
+      }
+
+      // Download regular file
+      const res = await drive.files.get(
+        { fileId, alt: "media" },
+        { responseType: mimeType?.startsWith("text/") ? "text" : "arraybuffer" }
+      );
+
+      if (mimeType?.startsWith("text/")) {
+        return textResponse(res.data);
+      }
+
+      // Binary — return base64
+      const buffer = Buffer.from(res.data);
+      return textResponse(`[Binary file: ${name} (${mimeType}, ${buffer.length} bytes)]\n\nBase64:\n${buffer.toString("base64")}`);
+    } catch (err) {
+      if (err.code === 404) {
+        return errorResponse(`File not found: ${fileId}. Verify the file ID exists and you have access.`);
+      }
+      return errorResponse(err.message);
+    }
+  }
+);
+
+// ─── Tool: gdrive_create_file ────────────────────────────────────────────────
+
+server.registerTool(
+  "gdrive_create_file",
+  {
+    description:
+      "Create a new file in Google Drive with the specified name and content. " +
+      "Optionally specify a parent folder and MIME type.",
+    inputSchema: {
+      name: z.string().describe("File name including extension (e.g., 'notes.txt')"),
+      content: z.string().describe("File content (text)"),
+      mimeType: z.string().optional().default("text/plain").describe("MIME type of content"),
+      parentFolderId: z.string().optional().describe("Parent folder ID (default: root)"),
+    },
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true,
+    },
+  },
+  async ({ name, content, mimeType, parentFolderId }) => {
+    try {
+      const drive = await getDrive();
+
+      const fileMetadata = { name };
+      if (parentFolderId) fileMetadata.parents = [parentFolderId];
+
+      const media = {
+        mimeType: mimeType || "text/plain",
+        body: content,
+      };
+
+      const res = await drive.files.create({
+        requestBody: fileMetadata,
+        media,
+        fields: "id,name,mimeType,webViewLink",
+      });
+
+      return jsonResponse(res.data);
+    } catch (err) {
+      if (err.code === 404) {
+        return errorResponse(`Parent folder not found: ${parentFolderId}`);
+      }
+      return errorResponse(err.message);
+    }
+  }
+);
+
+// ─── Tool: gdrive_create_folder ──────────────────────────────────────────────
+
+server.registerTool(
+  "gdrive_create_folder",
+  {
+    description:
+      "Create a new folder in Google Drive. Optionally specify a parent folder.",
+    inputSchema: {
+      name: z.string().describe("Folder name"),
+      parentFolderId: z.string().optional().describe("Parent folder ID (default: root)"),
+    },
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true,
+    },
+  },
+  async ({ name, parentFolderId }) => {
+    try {
+      const drive = await getDrive();
+
+      const fileMetadata = {
+        name,
+        mimeType: "application/vnd.google-apps.folder",
+      };
+      if (parentFolderId) fileMetadata.parents = [parentFolderId];
+
+      const res = await drive.files.create({
+        requestBody: fileMetadata,
+        fields: "id,name,mimeType,webViewLink",
+      });
+
+      return jsonResponse(res.data);
+    } catch (err) {
+      if (err.code === 404) {
+        return errorResponse(`Parent folder not found: ${parentFolderId}`);
+      }
+      return errorResponse(err.message);
+    }
+  }
+);
+
+// ─── Start ───────────────────────────────────────────────────────────────────
+
+async function main() {
+  // Handle --auth flag for interactive first-run authorization
+  if (process.argv.includes("--auth")) {
+    await interactiveAuth();
+    process.exit(0);
+  }
+
+  try {
+    authClient = await authorize();
+    driveClient = google.drive({ version: "v3", auth: authClient });
+  } catch (err) {
+    process.stderr.write(`\nAuth error: ${err.message}\n`);
+    process.exit(1);
+  }
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((err) => {
+  process.stderr.write(`\nFatal: ${err.message}\n`);
+  process.exit(1);
+});