google-tools-mcp 1.0.13 → 1.0.15

package/README.md

@@ -235,6 +235,7 @@ Google Forms — create/read forms, manage responses, and publish settings.
 | `GOOGLE_CLIENT_SECRET` | No* | OAuth 2.0 Client Secret |
 | `GOOGLE_MCP_PROFILE` | No | Profile name for multi-account support (see above) |
 | `LOG_LEVEL` | No | `debug`, `info`, `warn`, `error`, or `silent` |
+| `GOOGLE_MCP_LOG_FILE` | No | Set to `1` to log to `~/.config/google-tools-mcp/server.log`, or set to a custom file path |
 | `SERVICE_ACCOUNT_PATH` | No | Path to service account JSON key (alternative to OAuth) |
 | `GOOGLE_IMPERSONATE_USER` | No | Email to impersonate with service account |
 

package/dist/auth.js

@@ -259,7 +259,7 @@ async function authenticate() {
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
-export { getTokenPath };
+export { getTokenPath, getConfigDir, SCOPES };
 
 export async function authorize() {
     if (process.env.SERVICE_ACCOUNT_PATH) {
@@ -271,12 +271,16 @@ export async function authorize() {
     if (client) {
         // Proactively refresh to verify the token is still valid
         try {
+            logger.info('Refreshing access token...');
             const { credentials } = await client.refreshAccessToken();
             client.setCredentials(credentials);
             if (credentials.refresh_token) {
                 await saveCredentials(client);
             }
-            logger.info('Using saved credentials (token refreshed successfully).');
+            const expiryDate = credentials.expiry_date
+                ? new Date(credentials.expiry_date).toISOString()
+                : 'unknown';
+            logger.info(`Token refreshed successfully. Expires: ${expiryDate}`);
             return client;
         } catch (err) {
             const isInvalidGrant = err.message?.includes('invalid_grant') ||
@@ -286,6 +290,7 @@ export async function authorize() {
                 try { await fs.unlink(getTokenPath()); } catch {}
                 return authenticate();
             }
+            logger.error('Token refresh failed:', err.message || err);
             throw err;
         }
     }

package/dist/clients.js

@@ -94,6 +94,11 @@ export async function initializeFormsClient() {
     return { authClient, formsClient };
 }
 
+// --- Get auth client without triggering init (for diagnostics) ---
+export function getAuthClientIfReady() {
+    return authClient;
+}
+
 // --- Reset all clients (used by logout) ---
 export function resetClients() {
     authClient = null;

package/dist/index.js

@@ -24,14 +24,26 @@ if (process.argv[2] === 'auth') {
     }
 }
 
-// --- Server startup ---
+// --- Process lifecycle logging ---
 process.on('uncaughtException', (error) => {
     logger.error('Uncaught Exception:', error);
 });
 process.on('unhandledRejection', (reason, _promise) => {
     logger.error('Unhandled Promise Rejection:', reason);
 });
+process.on('SIGINT', () => {
+    logger.info('Received SIGINT — shutting down.');
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    logger.info('Received SIGTERM — shutting down.');
+    process.exit(0);
+});
+process.on('exit', (code) => {
+    logger.info(`Process exiting with code ${code}.`);
+});
 
+// --- Server startup ---
 const server = new FastMCP({
     name: 'google-tools-mcp',
     version: '1.0.0',

package/dist/logger.js

@@ -1,5 +1,10 @@
 // Centralized logger with LOG_LEVEL support.
 // All log output goes to stderr (stdout reserved for MCP protocol).
+// If GOOGLE_MCP_LOG_FILE is set, logs are also appended to that file.
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
 const LOG_LEVELS = {
     debug: 0,
     info: 1,
@@ -21,25 +26,62 @@ export function refreshLogLevel() {
 function shouldLog(level) {
     return LOG_LEVELS[level] >= LOG_LEVELS[currentLevel];
 }
-export const logger = {
-    debug(...args) {
-        if (shouldLog('debug')) {
-            console.error('[DEBUG]', ...args);
-        }
-    },
-    info(...args) {
-        if (shouldLog('info')) {
-            console.error('[INFO]', ...args);
-        }
-    },
-    warn(...args) {
-        if (shouldLog('warn')) {
-            console.error('[WARN]', ...args);
-        }
-    },
-    error(...args) {
-        if (shouldLog('error')) {
-            console.error('[ERROR]', ...args);
+
+// --- File logging ---
+let logStream = null;
+
+function getDefaultLogPath() {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    const base = xdg || path.join(os.homedir(), '.config');
+    const baseDir = path.join(base, 'google-tools-mcp');
+    const profile = process.env.GOOGLE_MCP_PROFILE;
+    const dir = profile ? path.join(baseDir, profile) : baseDir;
+    return path.join(dir, 'server.log');
+}
+
+function initLogFile() {
+    if (logStream) return;
+    const logPath = process.env.GOOGLE_MCP_LOG_FILE === '1'
+        ? getDefaultLogPath()
+        : process.env.GOOGLE_MCP_LOG_FILE;
+    if (!logPath) return;
+    try {
+        fs.mkdirSync(path.dirname(logPath), { recursive: true });
+        logStream = fs.createWriteStream(logPath, { flags: 'a' });
+    } catch {
+        // If we can't open the log file, continue without file logging
+    }
+}
+initLogFile();
+
+function timestamp() {
+    return new Date().toISOString();
+}
+
+function formatArgs(args) {
+    return args.map(a => {
+        if (a instanceof Error) return a.stack || a.message;
+        if (typeof a === 'object') {
+            try { return JSON.stringify(a); } catch { return String(a); }
         }
-    },
+        return String(a);
+    }).join(' ');
+}
+
+function log(level, args) {
+    if (!shouldLog(level)) return;
+    const tag = level.toUpperCase();
+    const ts = timestamp();
+    const msg = formatArgs(args);
+    console.error(`${ts} [${tag}] ${msg}`);
+    if (logStream) {
+        logStream.write(`${ts} [${tag}] ${msg}\n`);
+    }
+}
+
+export const logger = {
+    debug(...args) { log('debug', args); },
+    info(...args) { log('info', args); },
+    warn(...args) { log('warn', args); },
+    error(...args) { log('error', args); },
 };

package/dist/tools/calendar/manageEvent.js

@@ -6,9 +6,9 @@ export function register(server) {
     server.addTool({
         name: 'manage_event',
         description:
-            'Create, update, or delete a calendar event. Supports attendees, Google Meet, reminders, attachments, visibility, and transparency settings.',
+            'Create, update, or delete a calendar event. Supports attendees, Google Meet, reminders, attachments, visibility, and transparency settings. IMPORTANT: To modify an existing event, always use action "update" with the existing event_id. Never delete and recreate an event to make changes — this destroys the event ID, attendee RSVPs, and sent notifications.',
         parameters: z.object({
-            action: z.enum(['create', 'update', 'delete']).describe('The operation to perform.'),
+            action: z.enum(['create', 'update', 'delete']).describe('The operation to perform. Use "update" to modify existing events — do not delete and recreate. "delete" should only be used to permanently remove an event, not to redo one.'),
             calendar_id: z
                 .string()
                 .optional()

package/dist/tools/index.js

@@ -5,9 +5,11 @@ import { z } from 'zod';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
-import { getTokenPath } from '../auth.js';
-import { resetClients, withAuthRetry } from '../clients.js';
+import * as os from 'os';
+import { getTokenPath, getConfigDir, SCOPES } from '../auth.js';
+import { resetClients, withAuthRetry, getAuthClientIfReady } from '../clients.js';
 import { logger } from '../logger.js';
+import { google } from 'googleapis';
 
 // ---------------------------------------------------------------------------
 // Wrap server.addTool so every tool's execute() auto-retries on invalid_grant.
@@ -140,4 +142,214 @@ export async function registerAllTools(server) {
             });
         },
     });
+
+    // --- Troubleshoot tool (always available) ---
+    server.addTool({
+        name: 'troubleshoot',
+        description:
+            'Run a health check on google-tools-mcp: verify OAuth token, test API connectivity, show config and recent logs. Call this when tools are failing or behaving unexpectedly.',
+        parameters: z.object({}),
+        execute: async () => {
+            const report = { auth: {}, services: {}, config: {}, recentLogs: null, environment: {} };
+
+            // --- Auth status ---
+            const tokenPath = getTokenPath();
+            try {
+                const tokenContent = await fs.readFile(tokenPath, 'utf8');
+                const token = JSON.parse(tokenContent);
+                report.auth.tokenFile = 'present';
+                report.auth.hasRefreshToken = !!token.refresh_token;
+                report.auth.type = token.type || 'unknown';
+            } catch (err) {
+                report.auth.tokenFile = err.code === 'ENOENT' ? 'missing' : 'unreadable';
+                report.auth.hasRefreshToken = false;
+            }
+
+            // Try refreshing token
+            const client = getAuthClientIfReady();
+            if (client) {
+                try {
+                    const { credentials } = await client.refreshAccessToken();
+                    client.setCredentials(credentials);
+                    report.auth.status = 'valid';
+                    report.auth.expiry = credentials.expiry_date
+                        ? new Date(credentials.expiry_date).toISOString()
+                        : 'unknown';
+                } catch (err) {
+                    report.auth.status = 'expired_or_revoked';
+                    report.auth.refreshError = err.message;
+                }
+            } else {
+                report.auth.status = report.auth.tokenFile === 'present' ? 'not_initialized' : 'missing';
+            }
+
+            // --- Service probes ---
+            if (client && report.auth.status === 'valid') {
+                // Drive
+                try {
+                    const drive = google.drive({ version: 'v3', auth: client });
+                    const res = await drive.about.get({ fields: 'user' });
+                    report.services.drive = { status: 'ok', account: res.data.user?.emailAddress || 'unknown' };
+                } catch (err) {
+                    report.services.drive = { status: 'error', error: err.message };
+                }
+
+                // Gmail
+                try {
+                    const gmail = google.gmail({ version: 'v1', auth: client });
+                    const res = await gmail.users.getProfile({ userId: 'me' });
+                    report.services.gmail = { status: 'ok', email: res.data.emailAddress || 'unknown' };
+                } catch (err) {
+                    report.services.gmail = { status: 'error', error: err.message };
+                }
+
+                // Calendar
+                try {
+                    const calendar = google.calendar({ version: 'v3', auth: client });
+                    await calendar.calendarList.list({ maxResults: 1 });
+                    report.services.calendar = { status: 'ok' };
+                } catch (err) {
+                    report.services.calendar = { status: 'error', error: err.message };
+                }
+
+                // Forms — just check scope presence
+                report.services.forms = {
+                    status: SCOPES.some(s => s.includes('forms')) ? 'configured' : 'no_scope',
+                };
+
+                // Docs/Sheets — covered by Drive auth
+                report.services.docs = { status: report.services.drive.status === 'ok' ? 'ok (via Drive auth)' : 'unknown' };
+                report.services.sheets = { status: report.services.drive.status === 'ok' ? 'ok (via Drive auth)' : 'unknown' };
+            } else {
+                report.services = { note: 'Skipped — auth not available' };
+            }
+
+            // --- Config summary ---
+            const configDir = getConfigDir();
+            report.config = {
+                configDir,
+                profile: process.env.GOOGLE_MCP_PROFILE || '(default)',
+                tokenPath,
+                credentialSource: process.env.GOOGLE_CLIENT_ID ? 'environment' : 'file',
+                scopes: SCOPES,
+                logFile: process.env.GOOGLE_MCP_LOG_FILE || '(not set)',
+            };
+
+            // --- Recent logs ---
+            const logFilePath = process.env.GOOGLE_MCP_LOG_FILE === '1'
+                ? path.join(configDir, 'server.log')
+                : process.env.GOOGLE_MCP_LOG_FILE;
+            if (logFilePath) {
+                try {
+                    const logContent = await fs.readFile(logFilePath, 'utf8');
+                    const lines = logContent.trimEnd().split('\n');
+                    report.recentLogs = lines.slice(-20);
+                } catch (err) {
+                    report.recentLogs = err.code === 'ENOENT' ? '(log file not found)' : `(error reading log: ${err.message})`;
+                }
+            } else {
+                report.recentLogs = '(file logging not enabled — set GOOGLE_MCP_LOG_FILE to enable)';
+            }
+
+            // --- Environment ---
+            const __dirname = path.dirname(fileURLToPath(import.meta.url));
+            let pkgVersion = 'unknown';
+            try {
+                const pkgPath = path.resolve(__dirname, '..', '..', 'package.json');
+                const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+                pkgVersion = pkg.version;
+            } catch {}
+            report.environment = {
+                serverVersion: pkgVersion,
+                nodeVersion: process.version,
+                platform: process.platform,
+                osRelease: os.release(),
+                arch: process.arch,
+            };
+
+            return JSON.stringify(report, null, 2);
+        },
+    });
+
+    // --- Feedback tool (always available) ---
+    server.addTool({
+        name: 'feedback',
+        description:
+            'Submit feedback or a bug report for google-tools-mcp. Automatically collects diagnostic info and generates a pre-filled GitHub issue URL.',
+        parameters: z.object({
+            type: z.enum(['bug', 'feature']).describe('Type of feedback'),
+            title: z.string().describe('Short summary'),
+            description: z.string().describe('Detailed description of the issue or feature request'),
+        }),
+        execute: async (args) => {
+            // Collect diagnostics
+            const __dirname = path.dirname(fileURLToPath(import.meta.url));
+            let pkgVersion = 'unknown';
+            try {
+                const pkgPath = path.resolve(__dirname, '..', '..', 'package.json');
+                const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+                pkgVersion = pkg.version;
+            } catch {}
+
+            let authStatus = 'unknown';
+            const tokenPath = getTokenPath();
+            try {
+                await fs.access(tokenPath);
+                const client = getAuthClientIfReady();
+                if (client) {
+                    try {
+                        await client.refreshAccessToken();
+                        authStatus = 'valid';
+                    } catch {
+                        authStatus = 'expired_or_revoked';
+                    }
+                } else {
+                    authStatus = 'not_initialized';
+                }
+            } catch {
+                authStatus = 'missing';
+            }
+
+            const enabledScopes = SCOPES.map(s => s.split('/').pop());
+
+            // Build markdown body
+            const diagnostics = [
+                `- **Server version:** ${pkgVersion}`,
+                `- **Node version:** ${process.version}`,
+                `- **OS:** ${process.platform} ${os.release()} (${process.arch})`,
+                `- **Auth status:** ${authStatus}`,
+                `- **Scopes:** ${enabledScopes.join(', ')}`,
+            ].join('\n');
+
+            const body = [
+                `## Description`,
+                ``,
+                args.description,
+                ``,
+                `<details>`,
+                `<summary>Diagnostic Info</summary>`,
+                ``,
+                diagnostics,
+                ``,
+                `</details>`,
+            ].join('\n');
+
+            // Build GitHub issue URL
+            const label = args.type === 'bug' ? 'bug' : 'enhancement';
+            const params = new URLSearchParams({
+                title: args.title,
+                body,
+                labels: label,
+            });
+            const url = `https://github.com/karthikcsq/google-tools-mcp/issues/new?${params.toString()}`;
+
+            return JSON.stringify({
+                url,
+                markdown: body,
+                note: url.length > 8000
+                    ? 'The URL may be too long for some browsers. Use the markdown body below to create the issue manually.'
+                    : 'Open the URL to create a pre-filled GitHub issue.',
+            }, null, 2);
+        },
+    });
 }

package/package.json

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