@starfysh/gdrive-mcp 1.0.1 → 1.1.0

package/README.md

@@ -1,12 +1,13 @@
-# Ultimate Google Docs, Sheets & Drive MCP Server
+# Ultimate Google Workspace MCP Server
 
 ![Demo Animation](assets/google.docs.mcp.1.gif)
 
-Connect Claude Desktop (or other MCP clients) to your Google Docs, Google Sheets, and Google Drive!
+Connect Claude Desktop (or other MCP clients) to Google Docs, Sheets, Drive, Slides, Forms, and Apps Script!
 
-> 🔥 **Check out [15 powerful tasks](SAMPLE_TASKS.md) you can accomplish with this enhanced server!**
-> 📁 **NEW:** Complete Google Drive file management capabilities!
-> 📊 **NEW:** Full Google Sheets support for reading, writing, and managing spreadsheets!
+> 🔥 **Check out [15 powerful tasks](SAMPLE_TASKS.md) you can accomplish with this server!**
+> 🎨 **NEW:** Google Slides support for presentations
+> 📋 **NEW:** Google Forms read-only access
+> 📜 **NEW:** Google Apps Script project management and execution
 
 This comprehensive server uses the Model Context Protocol (MCP) and the `fastmcp` library to provide tools for reading, writing, formatting, structuring Google Documents and Spreadsheets, and managing your entire Google Drive. It acts as a powerful bridge, allowing AI assistants like Claude to interact with your documents, spreadsheets, and files programmatically with advanced capabilities.
 
@@ -74,6 +75,25 @@ This comprehensive server uses the Model Context Protocol (MCP) and the `fastmcp
 - **Remove Access:** Revoke permissions with `removePermission` - remove specific users or groups from files
 - **Version History:** View file revisions with `listRevisions` - track changes for compliance and auditing
 
+### 🆕 Google Slides Support
+
+- **Read Presentations:** Get presentation metadata with `getPresentation` and list all slides with `listSlides`
+- **Create Presentations:** Create new presentations with `createPresentation`
+- **Manage Slides:** Get slide details with `getSlide`, add slides with `createSlide`, remove with `deleteSlide`
+
+### 🆕 Google Forms Support (Read-Only)
+
+- **Read Forms:** Get form structure and questions with `getForm` and `listFormQuestions`
+- **Read Responses:** Get all form responses with `listFormResponses` or specific ones with `getFormResponse`
+- ⚠️ **Note:** The Forms API only supports reading - form creation/editing must be done via the web interface
+
+### 🆕 Google Apps Script Support
+
+- **Manage Projects:** Get project details with `getScriptProject`, create with `createScriptProject`
+- **Manage Code:** Read scripts with `getScriptContent`, update with `updateScriptContent`
+- **Manage Versions:** List script versions with `listScriptVersions`, list deployments with `listScriptDeployments`
+- **Execute Scripts:** Run functions with `runScript` (requires API executable deployment)
+
 ### Integration
 
 - **Google Authentication:** Secure OAuth 2.0 authentication with full Drive, Docs, and Sheets access
@@ -488,6 +508,44 @@ While this MCP server provides comprehensive Google Docs, Sheets, and Drive func
 
 **Limited Support for Converted Documents**: Some Google Docs that were converted from other formats (especially Microsoft Word documents) may not support all Docs API operations. You may encounter errors like "This operation is not supported for this document" when trying to read or modify these files.
 
+### Google Forms API Limitations
+
+**Read-Only Access**: The Google Forms API only supports **reading** form structure and responses. You cannot create, update, or delete forms or questions programmatically. This is a fundamental limitation of the [Google Forms API](https://developers.google.com/workspace/forms/api/reference/rest).
+
+- Forms can only be created and edited via the Google Forms web interface
+- The API can read form structure (questions, settings) and responses
+- See: [Google Forms API Documentation](https://developers.google.com/workspace/forms/api)
+
+### Google Slides API Limitations
+
+**No Batch Updates**: Unlike the Google Docs API, the Slides API does not support batch updates in the same way. Each modification requires individual API calls. See: [Google Slides API Documentation](https://developers.google.com/workspace/slides/api)
+
+### Google Apps Script API Limitations
+
+**No Project Listing**: The Apps Script API does not support listing all script projects. You must know the script ID to interact with a project. Script IDs can be found in the script editor URL: `script.google.com/d/{SCRIPT_ID}/edit`
+
+**Script Execution Requirements**: Running Apps Script functions via the API requires specific setup:
+
+1. The script must be deployed as an **API Executable**
+2. The calling application and script must share a **common Google Cloud project**
+3. The OAuth token must include **all scopes** used by the script
+4. Only scripts with at least one required scope can be executed
+
+See: [Execute Functions with the Apps Script API](https://developers.google.com/apps-script/api/how-tos/execute)
+
+## API Documentation References
+
+| API | Documentation | OAuth Scopes Reference |
+|-----|---------------|----------------------|
+| Google Docs | [developers.google.com/docs/api](https://developers.google.com/docs/api) | `auth/documents` |
+| Google Sheets | [developers.google.com/sheets/api](https://developers.google.com/sheets/api) | `auth/spreadsheets` |
+| Google Drive | [developers.google.com/drive/api](https://developers.google.com/drive/api) | `auth/drive` |
+| Google Slides | [developers.google.com/slides/api](https://developers.google.com/workspace/slides/api) | `auth/presentations` |
+| Google Forms | [developers.google.com/forms/api](https://developers.google.com/workspace/forms/api) | `auth/forms.body.readonly`, `auth/forms.responses.readonly` |
+| Apps Script | [developers.google.com/apps-script/api](https://developers.google.com/apps-script/api) | `auth/script.projects` |
+
+For the complete list of OAuth 2.0 scopes, see: [OAuth 2.0 Scopes for Google APIs](https://developers.google.com/identity/protocols/oauth2/scopes)
+
 ## Troubleshooting
 
 - **Claude shows "Failed" or "Could not attach":**
@@ -500,7 +558,7 @@ While this MCP server provides comprehensive Google Docs, Sheets, and Drive func
   - Ensure you enabled the correct APIs (Docs, Sheets, Drive).
   - Make sure you added your email as a Test User on the OAuth Consent Screen.
   - Verify the `credentials.json` file is correctly placed in the project root.
-  - **If you're upgrading from an older version:** You may need to delete your existing `token.json` file and re-authenticate to grant the new Sheets API scope.
+  - **If you're upgrading from an older version:** You may need to delete your existing `token.json` file and re-authenticate to grant new scopes (Sheets, Slides, Forms, Apps Script).
 - **Tab-related Errors:**
   - If you get "Tab with ID not found", use `listDocumentTabs` to see all available tab IDs
   - Ensure you're using the correct tab ID format (typically a short alphanumeric string)

package/dist/auth.js

@@ -30,9 +30,17 @@ const TOKEN_PATH = resolvePath('GDRIVE_MCP_TOKEN_PATH', 'token.json');
 const CREDENTIALS_PATH = resolvePath('GDRIVE_MCP_CREDENTIALS_PATH', 'credentials.json');
 // --- End of path calculation ---
 const SCOPES = [
+    // Core APIs
     'https://www.googleapis.com/auth/documents',
     'https://www.googleapis.com/auth/drive', // Full Drive access for listing, searching, and document discovery
-    'https://www.googleapis.com/auth/spreadsheets' // Google Sheets API access
+    'https://www.googleapis.com/auth/spreadsheets', // Google Sheets API access
+    // Slides API
+    'https://www.googleapis.com/auth/presentations',
+    // Forms API (read-only - API doesn't support writes)
+    'https://www.googleapis.com/auth/forms.body.readonly',
+    'https://www.googleapis.com/auth/forms.responses.readonly',
+    // Apps Script API
+    'https://www.googleapis.com/auth/script.projects',
 ];
 // --- NEW FUNCTION: Handles Service Account Authentication ---
 // This entire function is new. It is called only when the
@@ -51,21 +59,13 @@ async function authorizeWithServiceAccount() {
             subject: impersonateUser, // Enables domain-wide delegation when set
         });
         await auth.authorize();
-        if (impersonateUser) {
-            console.error(`Service Account authentication successful, impersonating: ${impersonateUser}`);
-        }
-        else {
-            console.error('Service Account authentication successful!');
-        }
         return auth;
     }
     catch (error) {
         if (error.code === 'ENOENT') {
-            console.error(`FATAL: Service account key file not found at path: ${serviceAccountPath}`);
-            throw new Error(`Service account key file not found. Please check the path in SERVICE_ACCOUNT_PATH.`);
+            throw new Error(`Service account key file not found at: ${serviceAccountPath}`);
         }
-        console.error('FATAL: Error loading or authorizing the service account key:', error.message);
-        throw new Error('Failed to authorize using the service account. Ensure the key file is valid and the path is correct.');
+        throw new Error(`Service account auth failed: ${error.message}`);
     }
 }
 // --- END OF NEW FUNCTION---
@@ -83,17 +83,43 @@ async function loadSavedCredentialsIfExist() {
     }
 }
 async function loadClientSecrets() {
-    const content = await fs.readFile(CREDENTIALS_PATH);
-    const keys = JSON.parse(content.toString());
-    const key = keys.installed || keys.web;
-    if (!key)
-        throw new Error("Could not find client secrets in credentials.json.");
-    return {
-        client_id: key.client_id,
-        client_secret: key.client_secret,
-        redirect_uris: key.redirect_uris || ['http://localhost:3000/'], // Default for web clients
-        client_type: keys.web ? 'web' : 'installed'
-    };
+    try {
+        const content = await fs.readFile(CREDENTIALS_PATH);
+        const keys = JSON.parse(content.toString());
+        const key = keys.installed || keys.web;
+        if (!key)
+            throw new Error("Could not find client secrets in credentials.json.");
+        return {
+            client_id: key.client_id,
+            client_secret: key.client_secret,
+            redirect_uris: key.redirect_uris || ['http://localhost:3000/'],
+            client_type: keys.web ? 'web' : 'installed'
+        };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            console.error(`
+╔════════════════════════════════════════════════════════════════════╗
+║                    SETUP REQUIRED                                  ║
+╠════════════════════════════════════════════════════════════════════╣
+║  credentials.json not found!                                       ║
+║                                                                    ║
+║  To use this MCP server, you need Google OAuth credentials:       ║
+║                                                                    ║
+║  1. Go to: https://console.cloud.google.com/apis/credentials      ║
+║  2. Create OAuth 2.0 Client ID (Desktop app)                      ║
+║  3. Download JSON and save as: credentials.json                   ║
+║  4. Place in: ${process.cwd()}
+║     OR: ~/.config/gdrive-mcp/credentials.json                     ║
+║     OR: Set GDRIVE_MCP_CREDENTIALS_PATH env var                   ║
+║                                                                    ║
+║  Full guide: https://github.com/starfysh-tech/gdrive-mcp#setup    ║
+╚════════════════════════════════════════════════════════════════════╝
+`);
+            throw new Error('Setup required: credentials.json not found. See instructions above.');
+        }
+        throw error;
+    }
 }
 async function saveCredentials(client) {
     const { client_secret, client_id } = await loadClientSecrets();
@@ -104,39 +130,42 @@ async function saveCredentials(client) {
         refresh_token: client.credentials.refresh_token,
     });
     await fs.writeFile(TOKEN_PATH, payload);
-    console.error('Token stored to', TOKEN_PATH);
 }
 async function authenticate() {
     const { client_secret, client_id, redirect_uris, client_type } = await loadClientSecrets();
-    // For web clients, use the configured redirect URI; for desktop clients, use 'urn:ietf:wg:oauth:2.0:oob'
     const redirectUri = client_type === 'web' ? redirect_uris[0] : 'urn:ietf:wg:oauth:2.0:oob';
-    console.error(`DEBUG: Using redirect URI: ${redirectUri}`);
-    console.error(`DEBUG: Client type: ${client_type}`);
     const oAuth2Client = new google.auth.OAuth2(client_id, client_secret, redirectUri);
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const authorizeUrl = oAuth2Client.generateAuthUrl({
         access_type: 'offline',
         scope: SCOPES.join(' '),
     });
-    console.error('DEBUG: Generated auth URL:', authorizeUrl);
-    console.error('Authorize this app by visiting this url:', authorizeUrl);
-    const code = await rl.question('Enter the code from that page here: ');
+    console.error(`
+┌─────────────────────────────────────────────────────────────────┐
+│  Google Authorization Required                                  │
+├─────────────────────────────────────────────────────────────────┤
+│  1. Open this URL in your browser:                              │
+│                                                                 │
+│  ${authorizeUrl}
+│                                                                 │
+│  2. Sign in and grant access                                    │
+│  3. Copy the authorization code                                 │
+│  4. Paste it below                                              │
+└─────────────────────────────────────────────────────────────────┘
+`);
+    const code = await rl.question('Paste code here: ');
     rl.close();
     try {
         const { tokens } = await oAuth2Client.getToken(code);
         oAuth2Client.setCredentials(tokens);
-        if (tokens.refresh_token) { // Save only if we got a refresh token
+        if (tokens.refresh_token) {
             await saveCredentials(oAuth2Client);
         }
-        else {
-            console.error("Did not receive refresh token. Token might expire.");
-        }
-        console.error('Authentication successful!');
+        console.error('✓ Authenticated successfully!\n');
         return oAuth2Client;
     }
     catch (err) {
-        console.error('Error retrieving access token', err);
-        throw new Error('Authentication failed');
+        throw new Error('Authentication failed - check that you copied the full code');
     }
 }
 // --- MODIFIED: The Main Exported Function ---
@@ -145,19 +174,14 @@ async function authenticate() {
 export async function authorize() {
     // Check if the Service Account environment variable is set.
     if (process.env.SERVICE_ACCOUNT_PATH) {
-        console.error('Service account path detected. Attempting service account authentication...');
         return authorizeWithServiceAccount();
     }
     else {
         // If not, execute the original OAuth 2.0 flow exactly as it was.
-        console.error('No service account path detected. Falling back to standard OAuth 2.0 flow...');
         let client = await loadSavedCredentialsIfExist();
         if (client) {
-            // Optional: Add token refresh logic here if needed, though library often handles it.
-            console.error('Using saved credentials.');
             return client;
         }
-        console.error('Starting authentication flow...');
         client = await authenticate();
         return client;
     }

package/dist/server.js

@@ -1,42 +1,52 @@
 #!/usr/bin/env node
 // src/server.ts
+// Filter out noisy library warnings BEFORE importing FastMCP
+const originalStderrWrite = process.stderr.write.bind(process.stderr);
+process.stderr.write = (chunk, ...args) => {
+    if (typeof chunk === 'string' && chunk.includes('[FastMCP warning]'))
+        return true;
+    return originalStderrWrite(chunk, ...args);
+};
 import { FastMCP, UserError } from 'fastmcp';
 import { z } from 'zod';
 import { google } from 'googleapis';
 import { authorize } from './auth.js';
 // Import types and helpers
-import { DocumentIdParameter, OptionalRangeParameters, TextStyleParameters, ParagraphStyleParameters, ApplyTextStyleToolParameters, ApplyParagraphStyleToolParameters, NotImplementedError } from './types.js';
+import { DocumentIdParameter, OptionalRangeParameters, TextStyleParameters, ParagraphStyleParameters, ApplyTextStyleToolParameters, ApplyParagraphStyleToolParameters, NotImplementedError, PresentationIdParameter, FormIdParameter, ScriptIdParameter } from './types.js';
 import * as GDocsHelpers from './googleDocsApiHelpers.js';
 import * as SheetsHelpers from './googleSheetsApiHelpers.js';
 let authClient = null;
 let googleDocs = null;
 let googleDrive = null;
 let googleSheets = null;
+let googleSlides = null;
+let googleForms = null;
+let googleScript = null;
 // --- Initialization ---
 async function initializeGoogleClient() {
-    if (googleDocs && googleDrive && googleSheets)
-        return { authClient, googleDocs, googleDrive, googleSheets };
-    if (!authClient) { // Check authClient instead of googleDocs to allow re-attempt
+    if (googleDocs && googleDrive && googleSheets && googleSlides && googleForms && googleScript) {
+        return { authClient, googleDocs, googleDrive, googleSheets, googleSlides, googleForms, googleScript };
+    }
+    if (!authClient) {
         try {
-            console.error("Attempting to authorize Google API client...");
             const client = await authorize();
-            authClient = client; // Assign client here
+            authClient = client;
             googleDocs = google.docs({ version: 'v1', auth: authClient });
             googleDrive = google.drive({ version: 'v3', auth: authClient });
             googleSheets = google.sheets({ version: 'v4', auth: authClient });
-            console.error("Google API client authorized successfully.");
+            googleSlides = google.slides({ version: 'v1', auth: authClient });
+            googleForms = google.forms({ version: 'v1', auth: authClient });
+            googleScript = google.script({ version: 'v1', auth: authClient });
         }
         catch (error) {
-            console.error("FATAL: Failed to initialize Google API client:", error);
-            authClient = null; // Reset on failure
-            googleDocs = null;
-            googleDrive = null;
-            googleSheets = null;
-            // Decide if server should exit or just fail tools
-            throw new Error("Google client initialization failed. Cannot start server tools.");
+            // Setup errors already show friendly instructions
+            if (!error.message?.includes('Setup required')) {
+                console.error("Error:", error.message || error);
+            }
+            process.exit(1);
         }
     }
-    // Ensure googleDocs, googleDrive, and googleSheets are set if authClient is valid
+    // Ensure all clients are set if authClient is valid
     if (authClient && !googleDocs) {
         googleDocs = google.docs({ version: 'v1', auth: authClient });
     }
@@ -46,10 +56,19 @@ async function initializeGoogleClient() {
     if (authClient && !googleSheets) {
         googleSheets = google.sheets({ version: 'v4', auth: authClient });
     }
-    if (!googleDocs || !googleDrive || !googleSheets) {
-        throw new Error("Google Docs, Drive, and Sheets clients could not be initialized.");
+    if (authClient && !googleSlides) {
+        googleSlides = google.slides({ version: 'v1', auth: authClient });
+    }
+    if (authClient && !googleForms) {
+        googleForms = google.forms({ version: 'v1', auth: authClient });
+    }
+    if (authClient && !googleScript) {
+        googleScript = google.script({ version: 'v1', auth: authClient });
+    }
+    if (!googleDocs || !googleDrive || !googleSheets || !googleSlides || !googleForms || !googleScript) {
+        throw new Error("Google API clients could not be initialized.");
     }
-    return { authClient, googleDocs, googleDrive, googleSheets };
+    return { authClient, googleDocs, googleDrive, googleSheets, googleSlides, googleForms, googleScript };
 }
 // Set up process-level unhandled error/rejection handlers to prevent crashes
 process.on('uncaughtException', (error) => {
@@ -89,6 +108,30 @@ async function getSheetsClient() {
     }
     return sheets;
 }
+// --- Helper to get Slides client within tools ---
+async function getSlidesClient() {
+    const { googleSlides: slides } = await initializeGoogleClient();
+    if (!slides) {
+        throw new UserError("Google Slides client is not initialized. Authentication might have failed during startup or lost connection.");
+    }
+    return slides;
+}
+// --- Helper to get Forms client within tools ---
+async function getFormsClient() {
+    const { googleForms: forms } = await initializeGoogleClient();
+    if (!forms) {
+        throw new UserError("Google Forms client is not initialized. Authentication might have failed during startup or lost connection.");
+    }
+    return forms;
+}
+// --- Helper to get Script client within tools ---
+async function getScriptClient() {
+    const { googleScript: script } = await initializeGoogleClient();
+    if (!script) {
+        throw new UserError("Google Apps Script client is not initialized. Authentication might have failed during startup or lost connection.");
+    }
+    return script;
+}
 // === HELPER FUNCTIONS ===
 /**
  * Converts Google Docs JSON structure to Markdown format
@@ -2428,23 +2471,717 @@ server.addTool({
         }
     }
 });
+// =============================================
+// === GOOGLE SLIDES TOOLS ===
+// =============================================
+server.addTool({
+    name: 'getPresentation',
+    description: 'Gets metadata and structure of a Google Slides presentation.',
+    parameters: PresentationIdParameter,
+    execute: async (args, { log }) => {
+        const slides = await getSlidesClient();
+        log.info(`Getting presentation: ${args.presentationId}`);
+        try {
+            const response = await slides.presentations.get({
+                presentationId: args.presentationId,
+            });
+            const presentation = response.data;
+            const slideCount = presentation.slides?.length || 0;
+            let result = `**${presentation.title || 'Untitled Presentation'}**\n`;
+            result += `ID: ${presentation.presentationId}\n`;
+            result += `Slides: ${slideCount}\n\n`;
+            if (presentation.slides && presentation.slides.length > 0) {
+                result += `## Slides\n`;
+                presentation.slides.forEach((slide, index) => {
+                    result += `${index + 1}. Slide ID: ${slide.objectId}\n`;
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            log.error(`Error getting presentation: ${error.message}`);
+            if (error.code === 404)
+                throw new UserError(`Presentation not found (ID: ${args.presentationId}).`);
+            if (error.code === 403)
+                throw new UserError(`Permission denied for presentation (ID: ${args.presentationId}).`);
+            throw new UserError(`Failed to get presentation: ${error.message || 'Unknown error'}`);
+        }
+    }
+});
+server.addTool({
+    name: 'listSlides',
+    description: 'Lists all slides in a Google Slides presentation with their IDs and basic info.',
+    parameters: PresentationIdParameter,
+    execute: async (args, { log }) => {
+        const slides = await getSlidesClient();
+        log.info(`Listing slides for presentation: ${args.presentationId}`);
+        try {
+            const response = await slides.presentations.get({
+                presentationId: args.presentationId,
+            });
+            const presentation = response.data;
+            const slideList = presentation.slides || [];
+            if (slideList.length === 0) {
+                return 'This presentation has no slides.';
+            }
+            let result = `Found ${slideList.length} slide(s) in "${presentation.title || 'Untitled'}":\n\n`;
+            slideList.forEach((slide, index) => {
+                result += `**Slide ${index + 1}**\n`;
+                result += `  ID: ${slide.objectId}\n`;
+                const elementCount = slide.pageElements?.length || 0;
+                result += `  Elements: ${elementCount}\n\n`;
+            });
+            return result;
+        }
+        catch (error) {
+            log.error(`Error listing slides: ${error.message}`);
+            if (error.code === 404)
+                throw new UserError(`Presentation not found (ID: ${args.presentationId}).`);
+            if (error.code === 403)
+                throw new UserError(`Permission denied for presentation (ID: ${args.presentationId}).`);
+            throw new UserError(`Failed to list slides: ${error.message || 'Unknown error'}`);
+        }
+    }
+});
+server.addTool({
+    name: 'createPresentation',
+    description: 'Creates a new Google Slides presentation.',
+    parameters: z.object({
+        title: z.string().describe('The title for the new presentation.'),
+    }),
+    execute: async (args, { log }) => {
+        const slides = await getSlidesClient();
+        log.info(`Creating presentation: ${args.title}`);
+        try {
+            const response = await slides.presentations.create({
+                requestBody: {
+                    title: args.title,
+                },
+            });
+            const presentation = response.data;
+            return `Created presentation: "${presentation.title}"\nID: ${presentation.presentationId}\nLink: https://docs.google.com/presentation/d/${presentation.presentationId}/edit`;
+        }
+        catch (error) {
+            log.error(`Error creating presentation: ${error.message}`);
+            throw new UserError(`Failed to create presentation: ${error.message || 'Unknown error'}`);
+        }
+    }
+});
+server.addTool({
+    name: 'getSlide',
+    description: 'Gets detailed content of a specific slide in a presentation.',
+    parameters: PresentationIdParameter.extend({
+        slideId: z.string().describe('The object ID of the slide to retrieve.'),
+    }),
+    execute: async (args, { log }) => {
+        const slides = await getSlidesClient();
+        log.info(`Getting slide ${args.slideId} from presentation: ${args.presentationId}`);
+        try {
+            const response = await slides.presentations.pages.get({
+                presentationId: args.presentationId,
+                pageObjectId: args.slideId,
+            });
+            const slide = response.data;
+            let result = `**Slide: ${slide.objectId}**\n\n`;
+            if (slide.pageElements && slide.pageElements.length > 0) {
+                result += `## Elements (${slide.pageElements.length})\n`;
+                slide.pageElements.forEach((element, index) => {
+                    result += `${index + 1}. ID: ${element.objectId}`;
+                    if (element.shape) {
+                        result += ` (Shape: ${element.shape.shapeType || 'unknown'})`;
+                        if (element.shape.text?.textElements) {
+                            const textContent = element.shape.text.textElements
+                                .filter((te) => te.textRun?.content)
+                                .map((te) => te.textRun?.content)
+                                .join('');
+                            if (textContent.trim()) {
+                                result += `\n   Text: "${textContent.trim().substring(0, 100)}${textContent.length > 100 ? '...' : ''}"`;
+                            }
+                        }
+                    }
+                    if (element.image)
+                        result += ` (Image)`;
+                    if (element.table)
+                        result += ` (Table: ${element.table.rows}x${element.table.columns})`;
+                    result += `\n`;
+                });
+            }
+            else {
+                result += 'This slide has no elements.';
+            }
+            return result;
+        }
+        catch (error) {
+            log.error(`Error getting slide: ${error.message}`);
+            if (error.code === 404)
+                throw new UserError(`Slide or presentation not found.`);
+            if (error.code === 403)
+                throw new UserError(`Permission denied.`);
+            throw new UserError(`Failed to get slide: ${error.message || 'Unknown error'}`);
+        }
+    }
+});
+server.addTool({
+    name: 'createSlide',
+    description: 'Adds a new slide to a Google Slides presentation.',
+    parameters: PresentationIdParameter.extend({
+        insertionIndex: z.number().int().min(0).optional().describe('Position to insert the slide (0 = beginning). Defaults to end.'),
+        layoutType: z.enum(['BLANK', 'TITLE', 'TITLE_AND_BODY', 'TITLE_AND_TWO_COLUMNS', 'TITLE_ONLY', 'CAPTION_ONLY', 'BIG_NUMBER']).optional().default('BLANK').describe('The layout type for the new slide.'),
+    }),
+    execute: async (args, { log }) => {
+        const slides = await getSlidesClient();
+        log.info(`Creating slide in presentation: ${args.presentationId}`);
+        try {
+            const requests = [{
+                    createSlide: {
+                        insertionIndex: args.insertionIndex,
+                        slideLayoutReference: {
+                            predefinedLayout: args.layoutType,
+                        },
+                    },
+                }];
+            const response = await slides.presentations.batchUpdate({
+                presentationId: args.presentationId,
+                requestBody: { requests },
+            });
+            const createSlideResponse = response.data.replies?.[0]?.createSlide;
+            if (createSlideResponse?.objectId) {
+                return `Created new slide with ID: ${createSlideResponse.objectId}`;
+            }
+            return 'Slide created successfully.';
+        }
+        catch (error) {
+            log.error(`Error creating slide: ${error.message}`);
+            if (error.code === 404)
+                throw new UserError(`Presentation not found (ID: ${args.presentationId}).`);
+            if (error.code === 403)
+                throw new UserError(`Permission denied for presentation (ID: ${args.presentationId}).`);
+            throw new UserError(`Failed to create slide: ${error.message || 'Unknown error'}`);
+        }
+    }
+});
+server.addTool({
+    name: 'deleteSlide',
+    description: 'Deletes a slide from a Google Slides presentation.',
+    parameters: PresentationIdParameter.extend({
+        slideId: z.string().describe('The object ID of the slide to delete.'),
+    }),
+    execute: async (args, { log }) => {
+        const slides = await getSlidesClient();
+        log.info(`Deleting slide ${args.slideId} from presentation: ${args.presentationId}`);
+        try {
+            const requests = [{
+                    deleteObject: {
+                        objectId: args.slideId,
+                    },
+                }];
+            await slides.presentations.batchUpdate({
+                presentationId: args.presentationId,
+                requestBody: { requests },
+            });
+            return `Deleted slide: ${args.slideId}`;
+        }
+        catch (error) {
+            log.error(`Error deleting slide: ${error.message}`);
+            if (error.code === 404)
+                throw new UserError(`Slide or presentation not found.`);
+            if (error.code === 403)
+                throw new UserError(`Permission denied.`);
+            throw new UserError(`Failed to delete slide: ${error.message || 'Unknown error'}`);
+        }
+    }
+});
+// =============================================
+// === GOOGLE FORMS TOOLS (READ-ONLY) ===
+// =============================================
+server.addTool({
+    name: 'getForm',
+    description: 'Gets the structure and metadata of a Google Form. Note: Google Forms API is read-only.',
+    parameters: FormIdParameter,
+    execute: async (args, { log }) => {
+        const forms = await getFormsClient();
+        log.info(`Getting form: ${args.formId}`);
+        try {
+            const response = await forms.forms.get({
+                formId: args.formId,
+            });
+            const form = response.data;
+            let result = `**${form.info?.title || 'Untitled Form'}**\n`;
+            if (form.info?.description) {
+                result += `Description: ${form.info.description}\n`;
+            }
+            result += `Form ID: ${form.formId}\n`;
+            result += `Response URL: ${form.responderUri}\n`;
+            result += `Edit URL: https://docs.google.com/forms/d/${form.formId}/edit\n\n`;
+            const items = form.items || [];
+            result += `## Questions (${items.length})\n`;
+            items.forEach((item, index) => {
+                result += `\n${index + 1}. **${item.title || 'Untitled'}**`;
+                if (item.questionItem) {
+                    const question = item.questionItem.question;
+                    if (question?.choiceQuestion) {
+                        result += ` (${question.choiceQuestion.type || 'Choice'})`;
+                        const options = question.choiceQuestion.options || [];
+                        options.forEach((opt) => {
+                            result += `\n   - ${opt.value}`;
+                        });
+                    }
+                    else if (question?.textQuestion) {
+                        result += question.textQuestion.paragraph ? ' (Long answer)' : ' (Short answer)';
+                    }
+                    else if (question?.scaleQuestion) {
+                        result += ` (Scale: ${question.scaleQuestion.low}-${question.scaleQuestion.high})`;
+                    }
+                    if (question?.required)
+                        result += ' *Required*';
+                }
+                result += '\n';
+            });
+            return result;
+        }
+        catch (error) {
+            log.error(`Error getting form: ${error.message}`);
+            if (error.code === 404)
+                throw new UserError(`Form not found (ID: ${args.formId}).`);
+            if (error.code === 403)
+                throw new UserError(`Permission denied for form (ID: ${args.formId}).`);
+            throw new UserError(`Failed to get form: ${error.message || 'Unknown error'}`);
+        }
+    }
+});
+server.addTool({
+    name: 'listFormQuestions',
+    description: 'Lists all questions in a Google Form with their IDs and types.',
+    parameters: FormIdParameter,
+    execute: async (args, { log }) => {
+        const forms = await getFormsClient();
+        log.info(`Listing questions for form: ${args.formId}`);
+        try {
+            const response = await forms.forms.get({
+                formId: args.formId,
+            });
+            const form = response.data;
+            const items = form.items || [];
+            if (items.length === 0) {
+                return 'This form has no questions.';
+            }
+            let result = `Found ${items.length} item(s) in "${form.info?.title || 'Untitled'}":\n\n`;
+            items.forEach((item, index) => {
+                result += `**${index + 1}. ${item.title || 'Untitled'}**\n`;
+                result += `   Item ID: ${item.itemId}\n`;
+                if (item.questionItem) {
+                    const q = item.questionItem.question;
+                    if (q?.questionId)
+                        result += `   Question ID: ${q.questionId}\n`;
+                    if (q?.choiceQuestion)
+                        result += `   Type: ${q.choiceQuestion.type || 'Choice'}\n`;
+                    else if (q?.textQuestion)
+                        result += `   Type: ${q.textQuestion.paragraph ? 'Paragraph' : 'Text'}\n`;
+                    else if (q?.scaleQuestion)
+                        result += `   Type: Scale\n`;
+                    else if (q?.dateQuestion)
+                        result += `   Type: Date\n`;
+                    else if (q?.timeQuestion)
+                        result += `   Type: Time\n`;
+                    else if (q?.fileUploadQuestion)
+                        result += `   Type: File Upload\n`;
+                    if (q?.required)
+                        result += `   Required: Yes\n`;
+                }
+                else if (item.pageBreakItem) {
+                    result += `   Type: Page Break\n`;
+                }
+                else if (item.textItem) {
+                    result += `   Type: Text/Description\n`;
+                }
+                result += '\n';
+            });
+            return result;
+        }
+        catch (error) {
+            log.error(`Error listing form questions: ${error.message}`);
+            if (error.code === 404)
+                throw new UserError(`Form not found (ID: ${args.formId}).`);
+            if (error.code === 403)
+                throw new UserError(`Permission denied for form (ID: ${args.formId}).`);
+            throw new UserError(`Failed to list form questions: ${error.message || 'Unknown error'}`);
+        }
+    }
+});
+server.addTool({
+    name: 'listFormResponses',
+    description: 'Lists all responses submitted to a Google Form.',
+    parameters: FormIdParameter.extend({
+        maxResults: z.number().int().min(1).max(500).optional().default(50).describe('Maximum number of responses to return.'),
+    }),
+    execute: async (args, { log }) => {
+        const forms = await getFormsClient();
+        log.info(`Listing responses for form: ${args.formId}`);
+        try {
+            const response = await forms.forms.responses.list({
+                formId: args.formId,
+                pageSize: args.maxResults,
+            });
+            const responses = response.data.responses || [];
+            if (responses.length === 0) {
+                return 'This form has no responses yet.';
+            }
+            let result = `Found ${responses.length} response(s):\n\n`;
+            responses.forEach((resp, index) => {
+                result += `**Response ${index + 1}**\n`;
+                result += `  Response ID: ${resp.responseId}\n`;
+                result += `  Submitted: ${resp.lastSubmittedTime}\n`;
+                if (resp.respondentEmail) {
+                    result += `  Respondent: ${resp.respondentEmail}\n`;
+                }
+                result += '\n';
+            });
+            if (response.data.nextPageToken) {
+                result += `\n_More responses available. Showing first ${responses.length}._`;
+            }
+            return result;
+        }
+        catch (error) {
+            log.error(`Error listing form responses: ${error.message}`);
+            if (error.code === 404)
+                throw new UserError(`Form not found (ID: ${args.formId}).`);
+            if (error.code === 403)
+                throw new UserError(`Permission denied. Make sure you have access to view responses.`);
+            throw new UserError(`Failed to list responses: ${error.message || 'Unknown error'}`);
+        }
+    }
+});
+server.addTool({
+    name: 'getFormResponse',
+    description: 'Gets a specific response submitted to a Google Form with all answers.',
+    parameters: FormIdParameter.extend({
+        responseId: z.string().describe('The ID of the specific response to retrieve.'),
+    }),
+    execute: async (args, { log }) => {
+        const forms = await getFormsClient();
+        log.info(`Getting response ${args.responseId} for form: ${args.formId}`);
+        try {
+            // First get form structure to map question IDs to titles
+            const formResponse = await forms.forms.get({
+                formId: args.formId,
+            });
+            const form = formResponse.data;
+            const questionMap = new Map();
+            (form.items || []).forEach(item => {
+                if (item.questionItem?.question?.questionId && item.title) {
+                    questionMap.set(item.questionItem.question.questionId, item.title);
+                }
+            });
+            // Get the specific response
+            const response = await forms.forms.responses.get({
+                formId: args.formId,
+                responseId: args.responseId,
+            });
+            const resp = response.data;
+            let result = `**Response Details**\n`;
+            result += `Response ID: ${resp.responseId}\n`;
+            result += `Submitted: ${resp.lastSubmittedTime}\n`;
+            if (resp.respondentEmail) {
+                result += `Respondent: ${resp.respondentEmail}\n`;
+            }
+            result += `\n## Answers\n`;
+            const answers = resp.answers || {};
+            for (const [questionId, answer] of Object.entries(answers)) {
+                const questionTitle = questionMap.get(questionId) || questionId;
+                result += `\n**${questionTitle}**\n`;
+                const textAnswers = answer.textAnswers?.answers || [];
+                textAnswers.forEach((a) => {
+                    result += `  ${a.value}\n`;
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            log.error(`Error getting form response: ${error.message}`);
+            if (error.code === 404)
+                throw new UserError(`Form or response not found.`);
+            if (error.code === 403)
+                throw new UserError(`Permission denied.`);
+            throw new UserError(`Failed to get response: ${error.message || 'Unknown error'}`);
+        }
+    }
+});
+// =============================================
+// === GOOGLE APPS SCRIPT TOOLS ===
+// =============================================
+server.addTool({
+    name: 'listScriptDeployments',
+    description: 'Lists deployments for a Google Apps Script project.',
+    parameters: ScriptIdParameter.extend({
+        maxResults: z.number().int().min(1).max(50).optional().default(20).describe('Maximum number of deployments to return.'),
+    }),
+    execute: async (args, { log }) => {
+        const script = await getScriptClient();
+        log.info(`Listing deployments for script: ${args.scriptId}`);
+        try {
+            const response = await script.projects.deployments.list({
+                scriptId: args.scriptId,
+                pageSize: args.maxResults,
+            });
+            const deployments = response.data.deployments || [];
+            if (deployments.length === 0) {
+                return `No deployments found for script ${args.scriptId}.`;
+            }
+            let result = `Found ${deployments.length} deployment(s):\n\n`;
+            deployments.forEach((deployment, index) => {
+                result += `**${index + 1}. ${deployment.deploymentId}**\n`;
+                if (deployment.deploymentConfig) {
+                    result += `   Description: ${deployment.deploymentConfig.description || 'None'}\n`;
+                    result += `   Version: ${deployment.deploymentConfig.versionNumber || 'HEAD'}\n`;
+                }
+                if (deployment.updateTime) {
+                    result += `   Updated: ${deployment.updateTime}\n`;
+                }
+                result += '\n';
+            });
+            return result;
+        }
+        catch (error) {
+            log.error(`Error listing deployments: ${error.message}`);
+            if (error.code === 404)
+                throw new UserError(`Script project not found (ID: ${args.scriptId}).`);
+            if (error.code === 403)
+                throw new UserError(`Permission denied. Make sure the Apps Script API is enabled.`);
+            throw new UserError(`Failed to list deployments: ${error.message || 'Unknown error'}`);
+        }
+    }
+});
+server.addTool({
+    name: 'getScriptProject',
+    description: 'Gets metadata about a Google Apps Script project.',
+    parameters: ScriptIdParameter,
+    execute: async (args, { log }) => {
+        const script = await getScriptClient();
+        log.info(`Getting script project: ${args.scriptId}`);
+        try {
+            const response = await script.projects.get({
+                scriptId: args.scriptId,
+            });
+            const project = response.data;
+            let result = `**${project.title || 'Untitled Project'}**\n`;
+            result += `Script ID: ${project.scriptId}\n`;
+            result += `Create Time: ${project.createTime}\n`;
+            result += `Update Time: ${project.updateTime}\n`;
+            if (project.parentId) {
+                result += `Parent ID: ${project.parentId}\n`;
+            }
+            result += `\nEdit: https://script.google.com/d/${project.scriptId}/edit`;
+            return result;
+        }
+        catch (error) {
+            log.error(`Error getting script project: ${error.message}`);
+            if (error.code === 404)
+                throw new UserError(`Script project not found (ID: ${args.scriptId}).`);
+            if (error.code === 403)
+                throw new UserError(`Permission denied for script project.`);
+            throw new UserError(`Failed to get project: ${error.message || 'Unknown error'}`);
+        }
+    }
+});
+server.addTool({
+    name: 'createScriptProject',
+    description: 'Creates a new Google Apps Script project.',
+    parameters: z.object({
+        title: z.string().describe('The title for the new script project.'),
+        parentId: z.string().optional().describe('Optional: ID of a Drive folder, Docs, Sheets, or Forms file to bind the script to.'),
+    }),
+    execute: async (args, { log }) => {
+        const script = await getScriptClient();
+        log.info(`Creating script project: ${args.title}`);
+        try {
+            const response = await script.projects.create({
+                requestBody: {
+                    title: args.title,
+                    parentId: args.parentId,
+                },
+            });
+            const project = response.data;
+            return `Created script project: "${project.title}"\nScript ID: ${project.scriptId}\nEdit: https://script.google.com/d/${project.scriptId}/edit`;
+        }
+        catch (error) {
+            log.error(`Error creating script project: ${error.message}`);
+            throw new UserError(`Failed to create project: ${error.message || 'Unknown error'}`);
+        }
+    }
+});
+server.addTool({
+    name: 'getScriptContent',
+    description: 'Gets the source files of a Google Apps Script project.',
+    parameters: ScriptIdParameter,
+    execute: async (args, { log }) => {
+        const script = await getScriptClient();
+        log.info(`Getting content for script: ${args.scriptId}`);
+        try {
+            const response = await script.projects.getContent({
+                scriptId: args.scriptId,
+            });
+            const content = response.data;
+            const files = content.files || [];
+            if (files.length === 0) {
+                return 'This project has no files.';
+            }
+            let result = `Found ${files.length} file(s) in project:\n\n`;
+            files.forEach((file, index) => {
+                result += `**${index + 1}. ${file.name}** (${file.type})\n`;
+                result += '```\n';
+                result += (file.source || '(empty)').substring(0, 1000);
+                if ((file.source || '').length > 1000) {
+                    result += '\n... (truncated)';
+                }
+                result += '\n```\n\n';
+            });
+            return result;
+        }
+        catch (error) {
+            log.error(`Error getting script content: ${error.message}`);
+            if (error.code === 404)
+                throw new UserError(`Script project not found (ID: ${args.scriptId}).`);
+            if (error.code === 403)
+                throw new UserError(`Permission denied for script project.`);
+            throw new UserError(`Failed to get content: ${error.message || 'Unknown error'}`);
+        }
+    }
+});
+server.addTool({
+    name: 'updateScriptContent',
+    description: 'Updates the source files of a Google Apps Script project.',
+    parameters: ScriptIdParameter.extend({
+        files: z.array(z.object({
+            name: z.string().describe('File name (e.g., "Code", "Utils").'),
+            type: z.enum(['SERVER_JS', 'HTML', 'JSON']).describe('File type: SERVER_JS for .gs files, HTML for .html files, JSON for appsscript.json.'),
+            source: z.string().describe('The source code content.'),
+        })).describe('Array of files to update. This replaces all existing files.'),
+    }),
+    execute: async (args, { log }) => {
+        const script = await getScriptClient();
+        log.info(`Updating content for script: ${args.scriptId}`);
+        try {
+            const response = await script.projects.updateContent({
+                scriptId: args.scriptId,
+                requestBody: {
+                    files: args.files.map(f => ({
+                        name: f.name,
+                        type: f.type,
+                        source: f.source,
+                    })),
+                },
+            });
+            const updatedFiles = response.data.files || [];
+            return `Updated ${updatedFiles.length} file(s) in project.`;
+        }
+        catch (error) {
+            log.error(`Error updating script content: ${error.message}`);
+            if (error.code === 404)
+                throw new UserError(`Script project not found (ID: ${args.scriptId}).`);
+            if (error.code === 403)
+                throw new UserError(`Permission denied for script project.`);
+            throw new UserError(`Failed to update content: ${error.message || 'Unknown error'}`);
+        }
+    }
+});
+server.addTool({
+    name: 'listScriptVersions',
+    description: 'Lists all versions of a Google Apps Script project.',
+    parameters: ScriptIdParameter,
+    execute: async (args, { log }) => {
+        const script = await getScriptClient();
+        log.info(`Listing versions for script: ${args.scriptId}`);
+        try {
+            const response = await script.projects.versions.list({
+                scriptId: args.scriptId,
+                pageSize: 50,
+            });
+            const versions = response.data.versions || [];
+            if (versions.length === 0) {
+                return 'This project has no saved versions.';
+            }
+            let result = `Found ${versions.length} version(s):\n\n`;
+            versions.forEach((version, index) => {
+                result += `**Version ${version.versionNumber}**\n`;
+                if (version.description) {
+                    result += `   Description: ${version.description}\n`;
+                }
+                result += `   Created: ${version.createTime}\n\n`;
+            });
+            return result;
+        }
+        catch (error) {
+            log.error(`Error listing script versions: ${error.message}`);
+            if (error.code === 404)
+                throw new UserError(`Script project not found (ID: ${args.scriptId}).`);
+            if (error.code === 403)
+                throw new UserError(`Permission denied for script project.`);
+            throw new UserError(`Failed to list versions: ${error.message || 'Unknown error'}`);
+        }
+    }
+});
+server.addTool({
+    name: 'runScript',
+    description: 'Executes a function in a deployed Google Apps Script project. IMPORTANT: The script must be deployed as an API Executable and share a Cloud project with this application.',
+    parameters: ScriptIdParameter.extend({
+        functionName: z.string().describe('The name of the function to execute.'),
+        parameters: z.array(z.any()).optional().describe('Optional array of parameters to pass to the function.'),
+    }),
+    execute: async (args, { log }) => {
+        const script = await getScriptClient();
+        log.info(`Running function "${args.functionName}" in script: ${args.scriptId}`);
+        try {
+            const response = await script.scripts.run({
+                scriptId: args.scriptId,
+                requestBody: {
+                    function: args.functionName,
+                    parameters: args.parameters || [],
+                },
+            });
+            const result = response.data;
+            if (result.error) {
+                const errorDetails = result.error.details || [];
+                let errorMessage = `Script execution error: ${result.error.message || 'Unknown error'}`;
+                errorDetails.forEach((detail) => {
+                    if (detail.scriptStackTraceElements) {
+                        errorMessage += '\n\nStack trace:';
+                        detail.scriptStackTraceElements.forEach((element) => {
+                            errorMessage += `\n  at ${element.function} (line ${element.lineNumber})`;
+                        });
+                    }
+                });
+                throw new UserError(errorMessage);
+            }
+            if (result.response) {
+                const returnValue = result.response.result;
+                if (returnValue === undefined || returnValue === null) {
+                    return 'Function executed successfully (no return value).';
+                }
+                return `Function returned:\n${JSON.stringify(returnValue, null, 2)}`;
+            }
+            return 'Function executed successfully.';
+        }
+        catch (error) {
+            log.error(`Error running script: ${error.message}`);
+            if (error instanceof UserError)
+                throw error;
+            if (error.code === 404)
+                throw new UserError(`Script not found or not deployed as API Executable.`);
+            if (error.code === 403)
+                throw new UserError(`Permission denied. Ensure the script is deployed and shares a Cloud project with this application.`);
+            throw new UserError(`Failed to run script: ${error.message || 'Unknown error'}`);
+        }
+    }
+});
 // --- Server Startup ---
 async function startServer() {
     try {
-        await initializeGoogleClient(); // Authorize BEFORE starting listeners
-        console.error("Starting Ultimate Google Docs & Sheets MCP server...");
-        // Using stdio as before
-        const configToUse = {
-            transportType: "stdio",
-        };
-        // Start the server with proper error handling
-        server.start(configToUse);
-        console.error(`MCP Server running using ${configToUse.transportType}. Awaiting client connection...`);
-        // Log that error handling has been enabled
-        console.error('Process-level error handling configured to prevent crashes from timeout errors.');
+        await initializeGoogleClient();
+        server.start({ transportType: "stdio" });
+        console.error('✓ Google Workspace MCP server ready\n');
     }
     catch (startError) {
-        console.error("FATAL: Server failed to start:", startError.message || startError);
+        console.error("Server failed to start:", startError.message || startError);
         process.exit(1);
     }
 }

package/dist/types.js

@@ -96,6 +96,21 @@ export const ApplyParagraphStyleToolParameters = DocumentIdParameter.extend({
     ]).describe("Specify the target paragraph either by start/end indices, by finding text within it, or by providing an index within it."),
     style: ParagraphStyleParameters.refine(styleArgs => Object.values(styleArgs).some(v => v !== undefined), { message: "At least one paragraph style option must be provided." }).describe("The paragraph styling to apply.")
 });
+// --- Google Slides Parameter Schemas ---
+export const PresentationIdParameter = z.object({
+    presentationId: z.string().describe('The ID of the Google Slides presentation (from the URL).'),
+});
+export const SlideIdParameter = z.object({
+    slideId: z.string().optional().describe('The object ID of a specific slide/page. Use listSlides to find IDs.'),
+});
+// --- Google Forms Parameter Schemas ---
+export const FormIdParameter = z.object({
+    formId: z.string().describe('The ID of the Google Form (from the URL).'),
+});
+// --- Google Apps Script Parameter Schemas ---
+export const ScriptIdParameter = z.object({
+    scriptId: z.string().describe('The Apps Script project ID.'),
+});
 // --- Error Class ---
 // Use FastMCP's UserError for client-facing issues
 // Define a custom error for internal issues if needed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@starfysh/gdrive-mcp",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "type": "module",
   "description": "MCP server for Google Docs, Sheets, and Drive integration with Claude",
   "main": "dist/server.js",