google-tools-mcp 1.0.10 → 1.0.12

package/README.md

@@ -85,15 +85,28 @@ Add the credentials directly to your MCP configuration:
 
 #### Claude Code (recommended)
 
-If you used Option A or B above:
+**User-scope** (available in all projects):
+
+```bash
+claude mcp add -s user google -- npx -y google-tools-mcp
+```
+
+**Project-scope** (available only in the current project):
 
 ```bash
 claude mcp add google -- npx -y google-tools-mcp
 ```
 
-Or with env vars (Option C):
+With env vars (Option C):
 
 ```bash
+# User-scope
+claude mcp add -s user google \
+  -e GOOGLE_CLIENT_ID=your-client-id \
+  -e GOOGLE_CLIENT_SECRET=your-client-secret \
+  -- npx -y google-tools-mcp
+
+# Project-scope
 claude mcp add google \
   -e GOOGLE_CLIENT_ID=your-client-id \
   -e GOOGLE_CLIENT_SECRET=your-client-secret \
@@ -105,7 +118,7 @@ claude mcp add google \
 Via the `claude` CLI:
 
 ```bash
-claude mcp add google \
+claude mcp add -s user google \
   -e GOOGLE_MCP_PROFILE=myprofile \
   -- npx -y google-tools-mcp
 ```

package/dist/auth.js

@@ -269,8 +269,25 @@ export async function authorize() {
     logger.info('Attempting OAuth 2.0 authentication...');
     const client = await loadSavedCredentialsIfExist();
     if (client) {
-        logger.info('Using saved credentials.');
-        return client;
+        // Proactively refresh to verify the token is still valid
+        try {
+            const { credentials } = await client.refreshAccessToken();
+            client.setCredentials(credentials);
+            if (credentials.refresh_token) {
+                await saveCredentials(client);
+            }
+            logger.info('Using saved credentials (token refreshed successfully).');
+            return client;
+        } catch (err) {
+            const isInvalidGrant = err.message?.includes('invalid_grant') ||
+                err.response?.data?.error === 'invalid_grant';
+            if (isInvalidGrant) {
+                logger.warn('Saved refresh token is invalid/revoked. Starting re-authentication...');
+                try { await fs.unlink(getTokenPath()); } catch {}
+                return authenticate();
+            }
+            throw err;
+        }
     }
     logger.info('No saved token found. Starting interactive authentication flow...');
     return authenticate();

package/dist/clients.js

@@ -31,6 +31,33 @@ async function ensureAuth() {
     }
 }
 
+/**
+ * Re-authenticate and rebuild all API clients after an invalid_grant error.
+ */
+async function reauthorize() {
+    logger.info('Re-authorizing after invalid_grant...');
+    authClient = null;
+    googleDocs = null;
+    googleDrive = null;
+    googleSheets = null;
+    googleScript = null;
+    gmailClient = null;
+    calendarClient = null;
+    formsClient = null;
+    authClient = await authorize();
+    logger.info('Re-authorization successful.');
+}
+
+/**
+ * Check if an error is an invalid_grant error (expired/revoked refresh token).
+ */
+function isInvalidGrantError(error) {
+    if (!error) return false;
+    const msg = error.message || '';
+    const code = error.response?.data?.error || error.code || '';
+    return msg.includes('invalid_grant') || code === 'invalid_grant';
+}
+
 // --- GDrive clients ---
 export async function initializeGoogleClient() {
     if (googleDocs && googleDrive && googleSheets)
@@ -79,6 +106,24 @@ export function resetClients() {
     formsClient = null;
 }
 
+/**
+ * Execute a function with automatic re-auth on invalid_grant errors.
+ * Wraps any API call so that if the refresh token has been revoked mid-session,
+ * we re-authenticate transparently and retry once.
+ */
+export async function withAuthRetry(fn) {
+    try {
+        return await fn();
+    } catch (error) {
+        if (isInvalidGrantError(error)) {
+            logger.warn('Got invalid_grant during API call. Re-authenticating...');
+            await reauthorize();
+            return await fn();
+        }
+        throw error;
+    }
+}
+
 // --- Individual client getters ---
 export async function getDocsClient() {
     const { googleDocs: docs } = await initializeGoogleClient();

package/dist/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 // google-tools-mcp — Combined Google Workspace MCP server
 //
 // All tool categories (Drive, Docs, Sheets, Gmail, Calendar) are loaded at

package/dist/tools/calendar/manageEvent.js

@@ -69,6 +69,11 @@ export function register(server) {
                 .array(z.string())
                 .optional()
                 .describe('RRULE recurrence rules (e.g. ["RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR"]). Only for create.'),
+            send_updates: z
+                .enum(['all', 'externalOnly', 'none'])
+                .optional()
+                .default('all')
+                .describe('Who to send email notifications to: "all" = all attendees (default), "externalOnly" = non-Google Calendar attendees only, "none" = no emails.'),
         }),
         execute: async (args, { log }) => {
             const calendar = await getCalendarClient();
@@ -80,6 +85,7 @@ export function register(server) {
                     await calendar.events.delete({
                         calendarId: args.calendar_id,
                         eventId: args.event_id,
+                        sendUpdates: args.send_updates,
                     });
                     return JSON.stringify({ success: true, message: `Event ${args.event_id} deleted.` });
                 }
@@ -96,6 +102,7 @@ export function register(server) {
                         calendarId: args.calendar_id,
                         requestBody: eventBody,
                         conferenceDataVersion: args.add_google_meet ? 1 : 0,
+                        sendUpdates: args.send_updates,
                     };
 
                     const response = await calendar.events.insert(params);
@@ -119,6 +126,7 @@ export function register(server) {
                         eventId: args.event_id,
                         requestBody: eventBody,
                         conferenceDataVersion: args.add_google_meet !== undefined ? 1 : 0,
+                        sendUpdates: args.send_updates,
                     };
 
                     const response = await calendar.events.update(params);

package/dist/tools/calendar/moveEvent.js

@@ -17,6 +17,11 @@ export function register(server) {
             destination_calendar_id: z
                 .string()
                 .describe('Calendar ID to move the event to.'),
+            send_updates: z
+                .enum(['all', 'externalOnly', 'none'])
+                .optional()
+                .default('all')
+                .describe('Who to send email notifications to: "all" = all attendees (default), "externalOnly" = non-Google Calendar attendees only, "none" = no emails.'),
         }),
         execute: async (args, { log }) => {
             const calendar = await getCalendarClient();
@@ -29,6 +34,7 @@ export function register(server) {
                     calendarId: args.source_calendar_id,
                     eventId: args.event_id,
                     destination: args.destination_calendar_id,
+                    sendUpdates: args.send_updates,
                 });
 
                 const event = response.data;

package/dist/tools/index.js

@@ -6,9 +6,26 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { getTokenPath } from '../auth.js';
-import { resetClients } from '../clients.js';
+import { resetClients, withAuthRetry } from '../clients.js';
 import { logger } from '../logger.js';
 
+// ---------------------------------------------------------------------------
+// Wrap server.addTool so every tool's execute() auto-retries on invalid_grant.
+// ---------------------------------------------------------------------------
+function wrapServerWithAuthRetry(server) {
+    const originalAddTool = server.addTool.bind(server);
+    server.addTool = function (toolDef) {
+        const originalExecute = toolDef.execute;
+        if (originalExecute) {
+            toolDef.execute = function (...args) {
+                return withAuthRetry(() => originalExecute.apply(this, args));
+            };
+        }
+        return originalAddTool(toolDef);
+    };
+    return server;
+}
+
 // --- Category registry ---
 const CATEGORIES = {
     files: {
@@ -77,9 +94,12 @@ const CATEGORIES = {
 // Public: register all tools eagerly, plus the logout utility.
 // ---------------------------------------------------------------------------
 export async function registerAllTools(server) {
+    // Wrap server so every tool auto-retries on invalid_grant (expired refresh token)
+    const wrappedServer = wrapServerWithAuthRetry(server);
+
     // Load every category
     for (const [name, { loader }] of Object.entries(CATEGORIES)) {
-        await loader(server);
+        await loader(wrappedServer);
     }
     logger.info(`Loaded all ${Object.keys(CATEGORIES).length} categories at startup.`);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "google-tools-mcp",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "Combined Google Workspace MCP server (Drive, Docs, Sheets, Gmail) with lazy-loaded tool categories",
   "type": "module",
   "bin": {