mcp-google-docs 1.0.0

package/src/tools/docs.ts

@@ -0,0 +1,121 @@
+import { getClients } from '../auth.js';
+
+export async function readDocument(documentId: string): Promise<string> {
+  const { docs } = await getClients();
+  
+  const response = await docs.documents.get({ documentId });
+  const document = response.data;
+  
+  let text = '';
+  if (document.body?.content) {
+    for (const element of document.body.content) {
+      if (element.paragraph?.elements) {
+        for (const elem of element.paragraph.elements) {
+          if (elem.textRun?.content) {
+            text += elem.textRun.content;
+          }
+        }
+      }
+      if (element.table) {
+        text += '\n[TABLE]\n';
+        for (const row of element.table.tableRows || []) {
+          const cells: string[] = [];
+          for (const cell of row.tableCells || []) {
+            let cellText = '';
+            for (const content of cell.content || []) {
+              if (content.paragraph?.elements) {
+                for (const elem of content.paragraph.elements) {
+                  if (elem.textRun?.content) {
+                    cellText += elem.textRun.content.trim();
+                  }
+                }
+              }
+            }
+            cells.push(cellText);
+          }
+          text += cells.join(' | ') + '\n';
+        }
+        text += '[/TABLE]\n';
+      }
+    }
+  }
+  
+  return text;
+}
+
+export async function insertText(
+  documentId: string,
+  text: string,
+  index?: number
+): Promise<void> {
+  const { docs } = await getClients();
+  
+  const insertIndex = index ?? 1;
+  
+  await docs.documents.batchUpdate({
+    documentId,
+    requestBody: {
+      requests: [
+        {
+          insertText: {
+            location: { index: insertIndex },
+            text,
+          },
+        },
+      ],
+    },
+  });
+}
+
+export async function replaceText(
+  documentId: string,
+  searchText: string,
+  replaceText: string,
+  matchCase: boolean = false
+): Promise<number> {
+  const { docs } = await getClients();
+  
+  const response = await docs.documents.batchUpdate({
+    documentId,
+    requestBody: {
+      requests: [
+        {
+          replaceAllText: {
+            containsText: {
+              text: searchText,
+              matchCase,
+            },
+            replaceText,
+          },
+        },
+      ],
+    },
+  });
+  
+  const replies = response.data.replies || [];
+  return replies[0]?.replaceAllText?.occurrencesChanged || 0;
+}
+
+export async function appendText(
+  documentId: string,
+  text: string
+): Promise<void> {
+  const { docs } = await getClients();
+  
+  const doc = await docs.documents.get({ documentId });
+  const endIndex = doc.data.body?.content?.slice(-1)[0]?.endIndex || 1;
+  
+  await docs.documents.batchUpdate({
+    documentId,
+    requestBody: {
+      requests: [
+        {
+          insertText: {
+            location: { index: endIndex - 1 },
+            text,
+          },
+        },
+      ],
+    },
+  });
+}

package/src/tools/drive.ts

@@ -0,0 +1,80 @@
+import { getClients } from '../auth.js';
+import { DriveFile, MIME_TYPES } from '../types.js';
+
+export async function listFiles(
+  folderId?: string,
+  pageSize: number = 20
+): Promise<DriveFile[]> {
+  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: string,
+  fileType?: 'document' | 'spreadsheet' | 'folder',
+  pageSize: number = 20
+): Promise<DriveFile[]> {
+  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: string): Promise<DriveFile> {
+  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/src/tools/sheets.ts

@@ -0,0 +1,121 @@
+import { getClients } from '../auth.js';
+import { CellUpdate } from '../types.js';
+
+export async function readSheet(
+  spreadsheetId: string,
+  range: string
+): Promise<any[][]> {
+  const { sheets } = await getClients();
+  
+  const response = await sheets.spreadsheets.values.get({
+    spreadsheetId,
+    range,
+  });
+  
+  return response.data.values || [];
+}
+
+export async function getSheetInfo(spreadsheetId: string): Promise<{
+  title: string;
+  sheets: { id: number; title: string; rowCount: number; columnCount: number }[];
+}> {
+  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: string,
+  range: string,
+  value: string | number | boolean
+): Promise<void> {
+  const { sheets } = await getClients();
+  
+  await sheets.spreadsheets.values.update({
+    spreadsheetId,
+    range,
+    valueInputOption: 'USER_ENTERED',
+    requestBody: {
+      values: [[value]],
+    },
+  });
+}
+
+export async function updateRange(
+  spreadsheetId: string,
+  range: string,
+  values: any[][]
+): Promise<void> {
+  const { sheets } = await getClients();
+  
+  await sheets.spreadsheets.values.update({
+    spreadsheetId,
+    range,
+    valueInputOption: 'USER_ENTERED',
+    requestBody: { values },
+  });
+}
+
+export async function batchUpdate(
+  spreadsheetId: string,
+  sheetName: string,
+  updates: CellUpdate[]
+): Promise<number> {
+  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: string,
+  sheetName: string,
+  values: any[]
+): Promise<void> {
+  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: number): string {
+  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/src/types.ts

@@ -0,0 +1,45 @@
+import { google, 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 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',
+} as const;

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}