mcp-google-docs 1.0.0

package/dist/tools/drive.js

@@ -0,0 +1,61 @@
+import { getClients } from '../auth.js';
+import { MIME_TYPES } from '../types.js';
+export async function listFiles(folderId, pageSize = 20) {
+    const { drive } = await getClients();
+    let query = 'trashed = false';
+    if (folderId) {
+        query += ` and '${folderId}' in parents`;
+    }
+    const response = await drive.files.list({
+        q: query,
+        pageSize,
+        fields: 'files(id, name, mimeType, modifiedTime, webViewLink)',
+        orderBy: 'modifiedTime desc',
+    });
+    return (response.data.files || []).map(file => ({
+        id: file.id,
+        name: file.name,
+        mimeType: file.mimeType,
+        modifiedTime: file.modifiedTime || undefined,
+        webViewLink: file.webViewLink || undefined,
+    }));
+}
+export async function searchFiles(query, fileType, pageSize = 20) {
+    const { drive } = await getClients();
+    let searchQuery = `name contains '${query}' and trashed = false`;
+    if (fileType) {
+        const mimeType = fileType === 'document'
+            ? MIME_TYPES.DOCUMENT
+            : fileType === 'spreadsheet'
+                ? MIME_TYPES.SPREADSHEET
+                : MIME_TYPES.FOLDER;
+        searchQuery += ` and mimeType = '${mimeType}'`;
+    }
+    const response = await drive.files.list({
+        q: searchQuery,
+        pageSize,
+        fields: 'files(id, name, mimeType, modifiedTime, webViewLink)',
+        orderBy: 'modifiedTime desc',
+    });
+    return (response.data.files || []).map(file => ({
+        id: file.id,
+        name: file.name,
+        mimeType: file.mimeType,
+        modifiedTime: file.modifiedTime || undefined,
+        webViewLink: file.webViewLink || undefined,
+    }));
+}
+export async function getFileInfo(fileId) {
+    const { drive } = await getClients();
+    const response = await drive.files.get({
+        fileId,
+        fields: 'id, name, mimeType, modifiedTime, webViewLink',
+    });
+    return {
+        id: response.data.id,
+        name: response.data.name,
+        mimeType: response.data.mimeType,
+        modifiedTime: response.data.modifiedTime || undefined,
+        webViewLink: response.data.webViewLink || undefined,
+    };
+}

package/dist/tools/sheets.d.ts

@@ -0,0 +1,15 @@
+import { CellUpdate } from '../types.js';
+export declare function readSheet(spreadsheetId: string, range: string): Promise<any[][]>;
+export declare function getSheetInfo(spreadsheetId: string): Promise<{
+    title: string;
+    sheets: {
+        id: number;
+        title: string;
+        rowCount: number;
+        columnCount: number;
+    }[];
+}>;
+export declare function updateCell(spreadsheetId: string, range: string, value: string | number | boolean): Promise<void>;
+export declare function updateRange(spreadsheetId: string, range: string, values: any[][]): Promise<void>;
+export declare function batchUpdate(spreadsheetId: string, sheetName: string, updates: CellUpdate[]): Promise<number>;
+export declare function appendRow(spreadsheetId: string, sheetName: string, values: any[]): Promise<void>;

package/dist/tools/sheets.js

@@ -0,0 +1,81 @@
+import { getClients } from '../auth.js';
+export async function readSheet(spreadsheetId, range) {
+    const { sheets } = await getClients();
+    const response = await sheets.spreadsheets.values.get({
+        spreadsheetId,
+        range,
+    });
+    return response.data.values || [];
+}
+export async function getSheetInfo(spreadsheetId) {
+    const { sheets } = await getClients();
+    const response = await sheets.spreadsheets.get({
+        spreadsheetId,
+        fields: 'properties.title,sheets.properties',
+    });
+    return {
+        title: response.data.properties?.title || '',
+        sheets: (response.data.sheets || []).map(sheet => ({
+            id: sheet.properties?.sheetId || 0,
+            title: sheet.properties?.title || '',
+            rowCount: sheet.properties?.gridProperties?.rowCount || 0,
+            columnCount: sheet.properties?.gridProperties?.columnCount || 0,
+        })),
+    };
+}
+export async function updateCell(spreadsheetId, range, value) {
+    const { sheets } = await getClients();
+    await sheets.spreadsheets.values.update({
+        spreadsheetId,
+        range,
+        valueInputOption: 'USER_ENTERED',
+        requestBody: {
+            values: [[value]],
+        },
+    });
+}
+export async function updateRange(spreadsheetId, range, values) {
+    const { sheets } = await getClients();
+    await sheets.spreadsheets.values.update({
+        spreadsheetId,
+        range,
+        valueInputOption: 'USER_ENTERED',
+        requestBody: { values },
+    });
+}
+export async function batchUpdate(spreadsheetId, sheetName, updates) {
+    const { sheets } = await getClients();
+    const data = updates.map(update => ({
+        range: `${sheetName}!${columnToLetter(update.col)}${update.row}`,
+        values: [[update.value]],
+    }));
+    const response = await sheets.spreadsheets.values.batchUpdate({
+        spreadsheetId,
+        requestBody: {
+            valueInputOption: 'USER_ENTERED',
+            data,
+        },
+    });
+    return response.data.totalUpdatedCells || 0;
+}
+export async function appendRow(spreadsheetId, sheetName, values) {
+    const { sheets } = await getClients();
+    await sheets.spreadsheets.values.append({
+        spreadsheetId,
+        range: `${sheetName}!A:A`,
+        valueInputOption: 'USER_ENTERED',
+        insertDataOption: 'INSERT_ROWS',
+        requestBody: {
+            values: [values],
+        },
+    });
+}
+function columnToLetter(col) {
+    let letter = '';
+    while (col > 0) {
+        const mod = (col - 1) % 26;
+        letter = String.fromCharCode(65 + mod) + letter;
+        col = Math.floor((col - 1) / 26);
+    }
+    return letter;
+}

package/dist/types.d.ts

@@ -0,0 +1,33 @@
+import { drive_v3, docs_v1, sheets_v4 } from 'googleapis';
+export interface GoogleClients {
+    drive: drive_v3.Drive;
+    docs: docs_v1.Docs;
+    sheets: sheets_v4.Sheets;
+}
+export interface DriveFile {
+    id: string;
+    name: string;
+    mimeType: string;
+    modifiedTime?: string;
+    webViewLink?: string;
+}
+export interface SheetRange {
+    spreadsheetId: string;
+    range: string;
+}
+export interface CellUpdate {
+    row: number;
+    col: number;
+    value: string | number | boolean;
+}
+export interface BatchUpdateRequest {
+    spreadsheetId: string;
+    sheetName: string;
+    updates: CellUpdate[];
+}
+export declare const SCOPES: string[];
+export declare const MIME_TYPES: {
+    readonly FOLDER: "application/vnd.google-apps.folder";
+    readonly DOCUMENT: "application/vnd.google-apps.document";
+    readonly SPREADSHEET: "application/vnd.google-apps.spreadsheet";
+};

package/dist/types.js

@@ -0,0 +1,11 @@
+export const SCOPES = [
+    'https://www.googleapis.com/auth/drive.readonly',
+    'https://www.googleapis.com/auth/drive.file',
+    'https://www.googleapis.com/auth/documents',
+    'https://www.googleapis.com/auth/spreadsheets',
+];
+export const MIME_TYPES = {
+    FOLDER: 'application/vnd.google-apps.folder',
+    DOCUMENT: 'application/vnd.google-apps.document',
+    SPREADSHEET: 'application/vnd.google-apps.spreadsheet',
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "mcp-google-docs",
+  "version": "1.0.0",
+  "description": "MCP server for Google Drive, Docs and Sheets",
+  "main": "dist/index.js",
+  "bin": {
+    "mcp-google-docs": "./dist/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc && node dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "google-drive",
+    "google-docs",
+    "google-sheets",
+    "ai"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "googleapis": "^140.0.0",
+    "open": "^10.0.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/auth.ts

@@ -0,0 +1,145 @@
+import { google } from 'googleapis';
+import { OAuth2Client } from 'google-auth-library';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as http from 'http';
+import { URL } from 'url';
+import open from 'open';
+import { SCOPES, GoogleClients } from './types.js';
+
+const TOKEN_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.mcp-google-docs');
+const TOKEN_PATH = path.join(TOKEN_DIR, 'token.json');
+
+let oauth2Client: OAuth2Client | null = null;
+
+function getCredentials(): { clientId: string; clientSecret: string } {
+  const clientId = process.env.GOOGLE_CLIENT_ID;
+  const clientSecret = process.env.GOOGLE_CLIENT_SECRET;
+  
+  if (!clientId || !clientSecret) {
+    throw new Error('Missing GOOGLE_CLIENT_ID or GOOGLE_CLIENT_SECRET environment variables');
+  }
+  
+  return { clientId, clientSecret };
+}
+
+function createOAuth2Client(): OAuth2Client {
+  const { clientId, clientSecret } = getCredentials();
+  return new google.auth.OAuth2(clientId, clientSecret, 'http://localhost:3000/callback');
+}
+
+function loadToken(): any | null {
+  try {
+    if (fs.existsSync(TOKEN_PATH)) {
+      const content = fs.readFileSync(TOKEN_PATH, 'utf-8');
+      return JSON.parse(content);
+    }
+  } catch (error) {
+    console.error('Error loading token:', error);
+  }
+  return null;
+}
+
+function saveToken(token: any): void {
+  try {
+    if (!fs.existsSync(TOKEN_DIR)) {
+      fs.mkdirSync(TOKEN_DIR, { recursive: true });
+    }
+    fs.writeFileSync(TOKEN_PATH, JSON.stringify(token, null, 2));
+  } catch (error) {
+    console.error('Error saving token:', error);
+  }
+}
+
+export async function authenticate(): Promise<OAuth2Client> {
+  if (oauth2Client) {
+    return oauth2Client;
+  }
+
+  oauth2Client = createOAuth2Client();
+  const token = loadToken();
+
+  if (token) {
+    oauth2Client.setCredentials(token);
+    
+    if (token.expiry_date && token.expiry_date < Date.now()) {
+      try {
+        const { credentials } = await oauth2Client.refreshAccessToken();
+        oauth2Client.setCredentials(credentials);
+        saveToken(credentials);
+      } catch (error) {
+        oauth2Client = null;
+        throw new Error('Token expired. Please run auth_login again.');
+      }
+    }
+    return oauth2Client;
+  }
+
+  throw new Error('Not authenticated. Please run auth_login first.');
+}
+
+export async function startAuthFlow(): Promise<string> {
+  const client = createOAuth2Client();
+  
+  const authUrl = client.generateAuthUrl({
+    access_type: 'offline',
+    scope: SCOPES,
+    prompt: 'consent',
+  });
+
+  return new Promise((resolve, reject) => {
+    const server = http.createServer(async (req, res) => {
+      try {
+        const url = new URL(req.url!, `http://localhost:3000`);
+        if (url.pathname === '/callback') {
+          const code = url.searchParams.get('code');
+          if (code) {
+            const { tokens } = await client.getToken(code);
+            client.setCredentials(tokens);
+            saveToken(tokens);
+            oauth2Client = client;
+            
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end('<html><body><h1>授权成功！</h1><p>您可以关闭此窗口。</p></body></html>');
+            
+            server.close();
+            resolve('Authentication successful! Token saved.');
+          } else {
+            res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end('<html><body><h1>授权失败</h1></body></html>');
+            server.close();
+            reject(new Error('No authorization code received'));
+          }
+        }
+      } catch (error) {
+        res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end('<html><body><h1>错误</h1></body></html>');
+        server.close();
+        reject(error);
+      }
+    });
+
+    server.listen(3000, async () => {
+      console.error('Opening browser for authentication...');
+      await open(authUrl);
+    });
+
+    setTimeout(() => {
+      server.close();
+      reject(new Error('Authentication timeout (60s)'));
+    }, 60000);
+  });
+}
+
+export async function getClients(): Promise<GoogleClients> {
+  const auth = await authenticate();
+  return {
+    drive: google.drive({ version: 'v3', auth }),
+    docs: google.docs({ version: 'v1', auth }),
+    sheets: google.sheets({ version: 'v4', auth }),
+  };
+}
+
+export function isAuthenticated(): boolean {
+  return loadToken() !== null;
+}

package/src/index.ts

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { startAuthFlow, isAuthenticated } from './auth.js';
+import { listFiles, searchFiles, getFileInfo } from './tools/drive.js';
+import { readDocument, insertText, replaceText, appendText } from './tools/docs.js';
+import { readSheet, getSheetInfo, updateCell, updateRange, batchUpdate, appendRow } from './tools/sheets.js';
+
+const server = new Server(
+  { name: 'mcp-google-docs', version: '1.0.0' },
+  { capabilities: { tools: {} } }
+);
+
+// Tool definitions
+const TOOLS = [
+  {
+    name: 'auth_login',
+    description: 'Authenticate with Google. Opens browser for OAuth login. Run this first if not authenticated.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'auth_status',
+    description: 'Check if authenticated with Google.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'gdrive_list',
+    description: 'List files in Google Drive. Optionally filter by folder.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        folderId: { type: 'string', description: 'Folder ID to list files from (optional)' },
+        pageSize: { type: 'number', description: 'Number of files to return (default: 20)' },
+      },
+      required: [],
+    },
+  },
+  {
+    name: 'gdrive_search',
+    description: 'Search for files in Google Drive by name.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query (file name)' },
+        fileType: { type: 'string', enum: ['document', 'spreadsheet', 'folder'], description: 'Filter by file type' },
+        pageSize: { type: 'number', description: 'Number of results (default: 20)' },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'gdrive_info',
+    description: 'Get information about a specific file.',
+    inputSchema: {
+      type: 'object',
+      properties: { fileId: { type: 'string', description: 'File ID' } },
+      required: ['fileId'],
+    },
+  },
+  {
+    name: 'gdocs_read',
+    description: 'Read content from a Google Doc.',
+    inputSchema: {
+      type: 'object',
+      properties: { documentId: { type: 'string', description: 'Document ID' } },
+      required: ['documentId'],
+    },
+  },
+  {
+    name: 'gdocs_insert',
+    description: 'Insert text into a Google Doc at a specific position.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        documentId: { type: 'string', description: 'Document ID' },
+        text: { type: 'string', description: 'Text to insert' },
+        index: { type: 'number', description: 'Position to insert (default: 1, start of doc)' },
+      },
+      required: ['documentId', 'text'],
+    },
+  },
+  {
+    name: 'gdocs_append',
+    description: 'Append text to the end of a Google Doc.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        documentId: { type: 'string', description: 'Document ID' },
+        text: { type: 'string', description: 'Text to append' },
+      },
+      required: ['documentId', 'text'],
+    },
+  },
+  {
+    name: 'gdocs_replace',
+    description: 'Find and replace text in a Google Doc.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        documentId: { type: 'string', description: 'Document ID' },
+        searchText: { type: 'string', description: 'Text to find' },
+        replaceText: { type: 'string', description: 'Text to replace with' },
+        matchCase: { type: 'boolean', description: 'Case sensitive (default: false)' },
+      },
+      required: ['documentId', 'searchText', 'replaceText'],
+    },
+  },
+  {
+    name: 'gsheets_info',
+    description: 'Get spreadsheet info including sheet names.',
+    inputSchema: {
+      type: 'object',
+      properties: { spreadsheetId: { type: 'string', description: 'Spreadsheet ID' } },
+      required: ['spreadsheetId'],
+    },
+  },
+  {
+    name: 'gsheets_read',
+    description: 'Read data from a Google Sheet range.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        spreadsheetId: { type: 'string', description: 'Spreadsheet ID' },
+        range: { type: 'string', description: 'Range in A1 notation (e.g., Sheet1!A1:D10)' },
+      },
+      required: ['spreadsheetId', 'range'],
+    },
+  },
+  {
+    name: 'gsheets_update',
+    description: 'Update a single cell or range in a Google Sheet.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        spreadsheetId: { type: 'string', description: 'Spreadsheet ID' },
+        range: { type: 'string', description: 'Range in A1 notation (e.g., Sheet1!A1)' },
+        value: { type: 'string', description: 'Value to set (for single cell)' },
+        values: { type: 'array', description: 'Array of arrays for range update' },
+      },
+      required: ['spreadsheetId', 'range'],
+    },
+  },
+  {
+    name: 'gsheets_batch_update',
+    description: 'Batch update multiple cells in a Google Sheet.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        spreadsheetId: { type: 'string', description: 'Spreadsheet ID' },
+        sheetName: { type: 'string', description: 'Sheet name' },
+        updates: {
+          type: 'array',
+          description: 'Array of {row, col, value} objects. Row/col are 1-indexed.',
+          items: {
+            type: 'object',
+            properties: {
+              row: { type: 'number' },
+              col: { type: 'number' },
+              value: { type: ['string', 'number', 'boolean'] },
+            },
+          },
+        },
+      },
+      required: ['spreadsheetId', 'sheetName', 'updates'],
+    },
+  },
+  {
+    name: 'gsheets_append_row',
+    description: 'Append a new row to a Google Sheet.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        spreadsheetId: { type: 'string', description: 'Spreadsheet ID' },
+        sheetName: { type: 'string', description: 'Sheet name' },
+        values: { type: 'array', description: 'Array of values for the new row' },
+      },
+      required: ['spreadsheetId', 'sheetName', 'values'],
+    },
+  },
+];
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+// Tool call handler
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  
+  try {
+    switch (name) {
+      case 'auth_login': {
+        const result = await startAuthFlow();
+        return { content: [{ type: 'text', text: result }] };
+      }
+      
+      case 'auth_status': {
+        const authenticated = isAuthenticated();
+        return { 
+          content: [{ type: 'text', text: authenticated ? 'Authenticated' : 'Not authenticated. Run auth_login first.' }] 
+        };
+      }
+      
+      case 'gdrive_list': {
+        const files = await listFiles(args?.folderId as string, args?.pageSize as number);
+        return { content: [{ type: 'text', text: JSON.stringify(files, null, 2) }] };
+      }
+      
+      case 'gdrive_search': {
+        const files = await searchFiles(
+          args!.query as string,
+          args?.fileType as 'document' | 'spreadsheet' | 'folder',
+          args?.pageSize as number
+        );
+        return { content: [{ type: 'text', text: JSON.stringify(files, null, 2) }] };
+      }
+      
+      case 'gdrive_info': {
+        const info = await getFileInfo(args!.fileId as string);
+        return { content: [{ type: 'text', text: JSON.stringify(info, null, 2) }] };
+      }
+      
+      case 'gdocs_read': {
+        const content = await readDocument(args!.documentId as string);
+        return { content: [{ type: 'text', text: content }] };
+      }
+      
+      case 'gdocs_insert': {
+        await insertText(args!.documentId as string, args!.text as string, args?.index as number);
+        return { content: [{ type: 'text', text: 'Text inserted successfully' }] };
+      }
+      
+      case 'gdocs_append': {
+        await appendText(args!.documentId as string, args!.text as string);
+        return { content: [{ type: 'text', text: 'Text appended successfully' }] };
+      }
+      
+      case 'gdocs_replace': {
+        const count = await replaceText(
+          args!.documentId as string,
+          args!.searchText as string,
+          args!.replaceText as string,
+          args?.matchCase as boolean
+        );
+        return { content: [{ type: 'text', text: `Replaced ${count} occurrence(s)` }] };
+      }
+      
+      case 'gsheets_info': {
+        const info = await getSheetInfo(args!.spreadsheetId as string);
+        return { content: [{ type: 'text', text: JSON.stringify(info, null, 2) }] };
+      }
+      
+      case 'gsheets_read': {
+        const data = await readSheet(args!.spreadsheetId as string, args!.range as string);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+      }
+      
+      case 'gsheets_update': {
+        if (args?.values) {
+          await updateRange(args!.spreadsheetId as string, args!.range as string, args.values as any[][]);
+        } else {
+          await updateCell(args!.spreadsheetId as string, args!.range as string, args!.value as string);
+        }
+        return { content: [{ type: 'text', text: 'Updated successfully' }] };
+      }
+      
+      case 'gsheets_batch_update': {
+        const count = await batchUpdate(
+          args!.spreadsheetId as string,
+          args!.sheetName as string,
+          args!.updates as any[]
+        );
+        return { content: [{ type: 'text', text: `Updated ${count} cell(s)` }] };
+      }
+      
+      case 'gsheets_append_row': {
+        await appendRow(args!.spreadsheetId as string, args!.sheetName as string, args!.values as any[]);
+        return { content: [{ type: 'text', text: 'Row appended successfully' }] };
+      }
+      
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
+  }
+});
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('MCP Google Docs server running on stdio');
+}
+
+main().catch(console.error);