google-calendar-workspace-mcp-server 0.0.1 → 0.0.2

package/README.md

@@ -116,6 +116,36 @@ Add this configuration to your Claude Desktop config file:
 }
 ```
 
+## Tool Groups
+
+By default, all tools are enabled (read + write access). You can restrict the server to read-only operations by setting the `TOOL_GROUPS` environment variable:
+
+```json
+{
+  "mcpServers": {
+    "google-calendar": {
+      "command": "npx",
+      "args": ["google-calendar-workspace-mcp-server"],
+      "env": {
+        "GCAL_SERVICE_ACCOUNT_CLIENT_EMAIL": "...",
+        "GCAL_SERVICE_ACCOUNT_PRIVATE_KEY": "...",
+        "GCAL_IMPERSONATE_EMAIL": "...",
+        "TOOL_GROUPS": "calendar_readonly"
+      }
+    }
+  }
+}
+```
+
+**Available tool groups:**
+
+| Group               | Tools Included                                                                                      |
+| ------------------- | --------------------------------------------------------------------------------------------------- |
+| `calendar`          | All tools (read + write) - default                                                                  |
+| `calendar_readonly` | Read-only tools: `gcal_list_events`, `gcal_get_event`, `gcal_list_calendars`, `gcal_query_freebusy` |
+
+When using `calendar_readonly`, the `gcal_create_event` tool is not available.
+
 ## Available Tools
 
 ### gcal_list_events

package/build/index.integration-with-mock.js

@@ -3,9 +3,17 @@
  * Integration test entry point with mock Google Calendar client
  * Used by TestMCPClient for integration tests
  */
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { createMCPServer } from '../shared/index.js';
 import { logServerStart } from '../shared/logging.js';
+// Read version from package.json
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageJsonPath = join(__dirname, '..', 'package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+const VERSION = packageJson.version;
 /**
  * Mock Google Calendar client for integration tests
  */
@@ -185,7 +193,7 @@ class MockCalendarClient {
     }
 }
 async function main() {
-    const { server, registerHandlers } = createMCPServer();
+    const { server, registerHandlers } = createMCPServer({ version: VERSION });
     // Register handlers with mock client factory
     await registerHandlers(server, () => new MockCalendarClient());
     const transport = new StdioServerTransport();

package/build/index.js

@@ -1,7 +1,15 @@
 #!/usr/bin/env node
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { createMCPServer } from '../shared/index.js';
 import { logServerStart, logError } from '../shared/logging.js';
+// Read version from package.json
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageJsonPath = join(__dirname, '..', 'package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+const VERSION = packageJson.version;
 async function main() {
     // Validate required environment variables
     const requiredVars = [
@@ -20,7 +28,7 @@ async function main() {
         process.exit(1);
     }
     try {
-        const { server, registerHandlers } = createMCPServer();
+        const { server, registerHandlers } = createMCPServer({ version: VERSION });
         // Register handlers with default client factory
         await registerHandlers(server);
         const transport = new StdioServerTransport();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "google-calendar-workspace-mcp-server",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "MCP server for Google Calendar integration with service account support",
   "main": "build/index.js",
   "type": "module",

package/shared/index.d.ts

@@ -1,2 +1,3 @@
-export { createMCPServer, type ICalendarClient } from './server.js';
+export { createMCPServer, type ICalendarClient, type CreateMCPServerOptions } from './server.js';
+export { type ToolGroup } from './tools.js';
 export * from './types.js';

package/shared/server.d.ts

@@ -83,6 +83,22 @@ export declare class ServiceAccountCalendarClient implements ICalendarClient {
     queryFreebusy(request: FreeBusyRequest): Promise<FreeBusyResponse>;
 }
 export type ClientFactory = () => ICalendarClient;
+/**
+ * Options for creating the MCP server
+ */
+export interface CreateMCPServerOptions {
+    version: string;
+    /**
+     * Optional comma-separated list of tool groups to enable.
+     * Available groups:
+     * - 'calendar': All calendar tools (read + write)
+     * - 'calendar_readonly': Calendar tools (read only - excludes create_event)
+     *
+     * If not specified, defaults to 'calendar' (full access).
+     * Can also be set via TOOL_GROUPS environment variable.
+     */
+    enabledToolGroups?: string;
+}
 /**
  * Creates the default Google Calendar client based on environment variables.
  * Uses service account with domain-wide delegation:
@@ -91,7 +107,7 @@ export type ClientFactory = () => ICalendarClient;
  *   - GCAL_IMPERSONATE_EMAIL: Email address to impersonate
  */
 export declare function createDefaultClient(): ICalendarClient;
-export declare function createMCPServer(): {
+export declare function createMCPServer(options: CreateMCPServerOptions): {
     server: Server<{
         method: string;
         params?: {

package/shared/server.js

@@ -113,10 +113,10 @@ export function createDefaultClient() {
     };
     return new ServiceAccountCalendarClient(credentials, impersonateEmail);
 }
-export function createMCPServer() {
+export function createMCPServer(options) {
     const server = new Server({
         name: 'google-calendar-workspace-mcp-server',
-        version: '0.0.1',
+        version: options.version,
     }, {
         capabilities: {
             tools: {},
@@ -125,7 +125,7 @@ export function createMCPServer() {
     const registerHandlers = async (server, clientFactory) => {
         // Use provided factory or create default client
         const factory = clientFactory || createDefaultClient;
-        const registerTools = createRegisterTools(factory);
+        const registerTools = createRegisterTools(factory, options.enabledToolGroups);
         registerTools(server);
     };
     return { server, registerHandlers };

package/shared/tools.d.ts

@@ -1,3 +1,39 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import type { ClientFactory } from './server.js';
-export declare function createRegisterTools(clientFactory: ClientFactory): (server: Server) => void;
+/**
+ * Tool group definitions - groups of related tools that can be enabled/disabled together
+ *
+ * Each group has two variants:
+ * - Base group (e.g., 'calendar'): Includes all tools (read + write operations)
+ * - Readonly group (e.g., 'calendar_readonly'): Includes only read operations
+ *
+ * Groups:
+ * - calendar / calendar_readonly: All calendar tools (events, calendars, freebusy)
+ */
+export type ToolGroup = 'calendar' | 'calendar_readonly';
+/**
+ * Parse enabled tool groups from environment variable or parameter
+ * @param enabledGroupsParam - Comma-separated list of tool groups (e.g., "calendar_readonly")
+ * @returns Array of enabled tool groups
+ */
+export declare function parseEnabledToolGroups(enabledGroupsParam?: string): ToolGroup[];
+/**
+ * Creates a function to register all tools with the server.
+ * This pattern uses individual tool files for better modularity and testability.
+ *
+ * Each tool is defined in its own file under the `tools/` directory and follows
+ * a factory pattern that accepts the server and clientFactory as parameters.
+ *
+ * Tool groups can be enabled/disabled via the TOOL_GROUPS environment variable
+ * (comma-separated list, e.g., "calendar_readonly"). If not set, all
+ * base tool groups are enabled by default (full read+write access).
+ *
+ * Available tool groups:
+ * - calendar: All calendar tools (read + write)
+ * - calendar_readonly: Calendar tools (read only - excludes create_event)
+ *
+ * @param clientFactory - Factory function that creates client instances
+ * @param enabledGroups - Optional comma-separated list of enabled tool groups (overrides env var)
+ * @returns Function that registers all tools with a server
+ */
+export declare function createRegisterTools(clientFactory: ClientFactory, enabledGroups?: string): (server: Server) => void;

package/shared/tools.js

@@ -5,15 +5,91 @@ import { createEventTool } from './tools/create-event.js';
 import { listCalendarsTool } from './tools/list-calendars.js';
 import { queryFreebusyTool } from './tools/query-freebusy.js';
 const ALL_TOOLS = [
-    listEventsTool,
-    getEventTool,
-    createEventTool,
-    listCalendarsTool,
-    queryFreebusyTool,
+    // Calendar tools - read operations
+    { factory: listEventsTool, group: 'calendar', isWriteOperation: false },
+    { factory: getEventTool, group: 'calendar', isWriteOperation: false },
+    { factory: listCalendarsTool, group: 'calendar', isWriteOperation: false },
+    { factory: queryFreebusyTool, group: 'calendar', isWriteOperation: false },
+    // Calendar tools - write operations
+    { factory: createEventTool, group: 'calendar', isWriteOperation: true },
 ];
-export function createRegisterTools(clientFactory) {
+/**
+ * All valid tool groups (base groups and their _readonly variants)
+ */
+const VALID_TOOL_GROUPS = ['calendar', 'calendar_readonly'];
+/**
+ * Base groups (without _readonly suffix) - used for default "all groups" behavior
+ */
+const BASE_TOOL_GROUPS = ['calendar'];
+/**
+ * Parse enabled tool groups from environment variable or parameter
+ * @param enabledGroupsParam - Comma-separated list of tool groups (e.g., "calendar_readonly")
+ * @returns Array of enabled tool groups
+ */
+export function parseEnabledToolGroups(enabledGroupsParam) {
+    const groupsStr = enabledGroupsParam || process.env.TOOL_GROUPS || '';
+    if (!groupsStr) {
+        // Default: all base groups enabled (full read+write access)
+        return [...BASE_TOOL_GROUPS];
+    }
+    const groups = groupsStr.split(',').map((g) => g.trim());
+    const validGroups = [];
+    for (const group of groups) {
+        if (VALID_TOOL_GROUPS.includes(group) &&
+            !validGroups.includes(group)) {
+            validGroups.push(group);
+        }
+        else if (!VALID_TOOL_GROUPS.includes(group)) {
+            console.warn(`Unknown tool group: ${group}`);
+        }
+    }
+    return validGroups;
+}
+/**
+ * Check if a tool should be included based on enabled groups
+ * @param toolDef - The tool definition to check
+ * @param enabledGroups - Array of enabled tool groups
+ * @returns true if the tool should be included
+ */
+function shouldIncludeTool(toolDef, enabledGroups) {
+    const baseGroup = toolDef.group;
+    const readonlyGroup = `${baseGroup}_readonly`;
+    // Check if the base group (full access) is enabled
+    if (enabledGroups.includes(baseGroup)) {
+        return true;
+    }
+    // Check if the readonly group is enabled (only include read operations)
+    if (enabledGroups.includes(readonlyGroup) && !toolDef.isWriteOperation) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Creates a function to register all tools with the server.
+ * This pattern uses individual tool files for better modularity and testability.
+ *
+ * Each tool is defined in its own file under the `tools/` directory and follows
+ * a factory pattern that accepts the server and clientFactory as parameters.
+ *
+ * Tool groups can be enabled/disabled via the TOOL_GROUPS environment variable
+ * (comma-separated list, e.g., "calendar_readonly"). If not set, all
+ * base tool groups are enabled by default (full read+write access).
+ *
+ * Available tool groups:
+ * - calendar: All calendar tools (read + write)
+ * - calendar_readonly: Calendar tools (read only - excludes create_event)
+ *
+ * @param clientFactory - Factory function that creates client instances
+ * @param enabledGroups - Optional comma-separated list of enabled tool groups (overrides env var)
+ * @returns Function that registers all tools with a server
+ */
+export function createRegisterTools(clientFactory, enabledGroups) {
     return (server) => {
-        const tools = ALL_TOOLS.map((factory) => factory(server, clientFactory));
+        const enabledToolGroups = parseEnabledToolGroups(enabledGroups);
+        // Filter tools based on enabled groups
+        const enabledTools = ALL_TOOLS.filter((toolDef) => shouldIncludeTool(toolDef, enabledToolGroups));
+        // Create tool instances
+        const tools = enabledTools.map((toolDef) => toolDef.factory(server, clientFactory));
         server.setRequestHandler(ListToolsRequestSchema, async () => ({
             tools: tools.map((tool) => ({
                 name: tool.name,