@jnss95/ical-mcp 1.0.0

package/build/index.js

@@ -0,0 +1,707 @@
+#!/usr/bin/env node
+/**
+ * iCal MCP Server - Main entry point
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { loadCalendar, saveCalendar, createCalendarFile } from './calendar/index.js';
+// Store loaded calendars in memory
+const calendars = new Map();
+/**
+ * Create and configure the MCP server
+ */
+export function createServer() {
+    const server = new McpServer({
+        name: 'ical-mcp',
+        version: '1.0.0',
+    });
+    // Register all tools
+    registerTools(server);
+    return server;
+}
+/**
+ * Register all calendar tools with the MCP server
+ */
+function registerTools(server) {
+    // Tool: Load Calendar
+    server.tool('load_calendar', 'Load a calendar from a file path or URL. The calendar will be stored in memory and can be referenced by the provided ID.', {
+        calendarId: z.string().describe('A unique identifier for this calendar (used to reference it in other operations)'),
+        source: z.string().describe('File path or HTTP/HTTPS URL to the iCal file'),
+    }, async (args) => {
+        try {
+            const calendar = await loadCalendar(args.source);
+            calendars.set(args.calendarId, calendar);
+            const metadata = calendar.getMetadata();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            calendarId: args.calendarId,
+                            metadata,
+                            message: `Calendar loaded successfully with ${metadata.eventCount} events`,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : 'Unknown error',
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: Create Calendar
+    server.tool('create_calendar', 'Create a new empty calendar file at the specified path.', {
+        calendarId: z.string().describe('A unique identifier for this calendar'),
+        filePath: z.string().describe('File path where the calendar will be created'),
+        name: z.string().optional().describe('Optional name for the calendar'),
+        timezone: z.string().optional().describe('Optional timezone (e.g., "America/New_York")'),
+    }, async (args) => {
+        try {
+            const calendar = await createCalendarFile(args.filePath, { name: args.name, timezone: args.timezone });
+            calendars.set(args.calendarId, calendar);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            calendarId: args.calendarId,
+                            filePath: args.filePath,
+                            message: 'Calendar created successfully',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : 'Unknown error',
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: Get Calendar Info
+    server.tool('get_calendar_info', 'Get metadata and information about a loaded calendar.', {
+        calendarId: z.string().describe('The calendar identifier'),
+    }, async (args) => {
+        const calendar = calendars.get(args.calendarId);
+        if (!calendar) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: `Calendar "${args.calendarId}" not found. Load it first using load_calendar.`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const metadata = calendar.getMetadata();
+        const source = calendar.getSource();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        calendarId: args.calendarId,
+                        metadata,
+                        source: {
+                            type: source.type,
+                            writable: source.writable,
+                        },
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // Tool: List Events
+    server.tool('list_events', 'List all events in a calendar, optionally filtered by date range.', {
+        calendarId: z.string().describe('The calendar identifier'),
+        startDate: z.string().optional().describe('Start of date range (ISO 8601 format, e.g., "2024-01-01")'),
+        endDate: z.string().optional().describe('End of date range (ISO 8601 format, e.g., "2024-12-31")'),
+        limit: z.number().optional().describe('Maximum number of events to return'),
+        offset: z.number().optional().describe('Number of events to skip (for pagination)'),
+        expandRecurring: z.boolean().optional().describe('Expand recurring events into individual occurrences (default: true)'),
+    }, async (args) => {
+        const calendar = calendars.get(args.calendarId);
+        if (!calendar) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: `Calendar "${args.calendarId}" not found`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const options = {
+            startDate: args.startDate,
+            endDate: args.endDate,
+            limit: args.limit,
+            offset: args.offset,
+            expandRecurring: args.expandRecurring ?? true,
+        };
+        const result = calendar.queryEvents(options);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        ...result,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // Tool: Search Events
+    server.tool('search_events', 'Search for events matching specified criteria.', {
+        calendarId: z.string().describe('The calendar identifier'),
+        searchText: z.string().optional().describe('Text to search for in summary, description, and location'),
+        location: z.string().optional().describe('Filter by location'),
+        organizer: z.string().optional().describe('Filter by organizer'),
+        categories: z.array(z.string()).optional().describe('Filter by categories'),
+        startDate: z.string().optional().describe('Start of date range (ISO 8601)'),
+        endDate: z.string().optional().describe('End of date range (ISO 8601)'),
+        limit: z.number().optional().describe('Maximum number of results'),
+    }, async (args) => {
+        const calendar = calendars.get(args.calendarId);
+        if (!calendar) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: `Calendar "${args.calendarId}" not found`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const options = {
+            searchText: args.searchText,
+            location: args.location,
+            organizer: args.organizer,
+            categories: args.categories,
+            startDate: args.startDate,
+            endDate: args.endDate,
+            limit: args.limit,
+            expandRecurring: true,
+        };
+        const result = calendar.queryEvents(options);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        ...result,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // Tool: Get Event
+    server.tool('get_event', 'Get detailed information about a specific event by its UID.', {
+        calendarId: z.string().describe('The calendar identifier'),
+        eventId: z.string().describe('The event UID'),
+    }, async (args) => {
+        const calendar = calendars.get(args.calendarId);
+        if (!calendar) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: `Calendar "${args.calendarId}" not found`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const event = calendar.getEvent(args.eventId);
+        if (!event) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: `Event "${args.eventId}" not found`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        event,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // Tool: Create Event
+    server.tool('create_event', 'Create a new event in the calendar.', {
+        calendarId: z.string().describe('The calendar identifier'),
+        summary: z.string().describe('Event title/summary'),
+        start: z.string().describe('Start date/time (ISO 8601 format, e.g., "2024-01-15T10:00:00")'),
+        end: z.string().optional().describe('End date/time (ISO 8601 format). If not provided, defaults to start + 1 hour'),
+        description: z.string().optional().describe('Event description'),
+        location: z.string().optional().describe('Event location'),
+        allDay: z.boolean().optional().describe('Whether this is an all-day event'),
+        rrule: z.string().optional().describe('Recurrence rule (e.g., "FREQ=WEEKLY;COUNT=10")'),
+        organizer: z.string().optional().describe('Organizer email'),
+        attendees: z.array(z.string()).optional().describe('List of attendee emails'),
+        url: z.string().optional().describe('Event URL'),
+        categories: z.array(z.string()).optional().describe('Event categories'),
+        status: z.enum(['CONFIRMED', 'TENTATIVE', 'CANCELLED']).optional().describe('Event status'),
+    }, async (args) => {
+        const calendar = calendars.get(args.calendarId);
+        if (!calendar) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: `Calendar "${args.calendarId}" not found`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (!calendar.isWritable()) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: 'Calendar is read-only',
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        try {
+            const options = {
+                summary: args.summary,
+                start: args.start,
+                end: args.end,
+                description: args.description,
+                location: args.location,
+                allDay: args.allDay,
+                rrule: args.rrule,
+                organizer: args.organizer,
+                attendees: args.attendees,
+                url: args.url,
+                categories: args.categories,
+                status: args.status,
+            };
+            const event = calendar.createEvent(options);
+            // Save changes if this is a file-based calendar
+            const source = calendar.getSource();
+            if (source.type === 'file') {
+                await saveCalendar(calendar);
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: 'Event created successfully',
+                            event,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : 'Unknown error',
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: Update Event
+    server.tool('update_event', 'Update an existing event.', {
+        calendarId: z.string().describe('The calendar identifier'),
+        eventId: z.string().describe('The event UID to update'),
+        summary: z.string().optional().describe('New event title/summary'),
+        start: z.string().optional().describe('New start date/time (ISO 8601 format)'),
+        end: z.string().optional().describe('New end date/time (ISO 8601 format)'),
+        description: z.string().optional().describe('New event description'),
+        location: z.string().optional().describe('New event location'),
+        allDay: z.boolean().optional().describe('Whether this is an all-day event'),
+        rrule: z.string().optional().describe('New recurrence rule'),
+        organizer: z.string().optional().describe('New organizer email'),
+        attendees: z.array(z.string()).optional().describe('New list of attendee emails'),
+        url: z.string().optional().describe('New event URL'),
+        categories: z.array(z.string()).optional().describe('New event categories'),
+        status: z.enum(['CONFIRMED', 'TENTATIVE', 'CANCELLED']).optional().describe('New event status'),
+    }, async (args) => {
+        const calendar = calendars.get(args.calendarId);
+        if (!calendar) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: `Calendar "${args.calendarId}" not found`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (!calendar.isWritable()) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: 'Calendar is read-only',
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        try {
+            const options = {
+                summary: args.summary,
+                start: args.start,
+                end: args.end,
+                description: args.description,
+                location: args.location,
+                allDay: args.allDay,
+                rrule: args.rrule,
+                organizer: args.organizer,
+                attendees: args.attendees,
+                url: args.url,
+                categories: args.categories,
+                status: args.status,
+            };
+            const event = calendar.updateEvent(args.eventId, options);
+            // Save changes if this is a file-based calendar
+            const source = calendar.getSource();
+            if (source.type === 'file') {
+                await saveCalendar(calendar);
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: 'Event updated successfully',
+                            event,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : 'Unknown error',
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: Delete Event
+    server.tool('delete_event', 'Delete an event from the calendar.', {
+        calendarId: z.string().describe('The calendar identifier'),
+        eventId: z.string().describe('The event UID to delete'),
+    }, async (args) => {
+        const calendar = calendars.get(args.calendarId);
+        if (!calendar) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: `Calendar "${args.calendarId}" not found`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (!calendar.isWritable()) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: 'Calendar is read-only',
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        try {
+            const deleted = calendar.deleteEvent(args.eventId);
+            if (!deleted) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: `Event "${args.eventId}" not found`,
+                            }, null, 2),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            // Save changes if this is a file-based calendar
+            const source = calendar.getSource();
+            if (source.type === 'file') {
+                await saveCalendar(calendar);
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: 'Event deleted successfully',
+                            eventId: args.eventId,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : 'Unknown error',
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: List Loaded Calendars
+    server.tool('list_loaded_calendars', 'List all currently loaded calendars.', {}, async () => {
+        const calendarList = Array.from(calendars.entries()).map(([id, calendar]) => ({
+            id,
+            metadata: calendar.getMetadata(),
+            source: {
+                type: calendar.getSource().type,
+                writable: calendar.getSource().writable,
+            },
+        }));
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        calendars: calendarList,
+                        count: calendarList.length,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // Tool: Unload Calendar
+    server.tool('unload_calendar', 'Unload a calendar from memory.', {
+        calendarId: z.string().describe('The calendar identifier to unload'),
+    }, async (args) => {
+        if (!calendars.has(args.calendarId)) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: `Calendar "${args.calendarId}" not found`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        calendars.delete(args.calendarId);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        message: `Calendar "${args.calendarId}" unloaded successfully`,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // Tool: Export Calendar
+    server.tool('export_calendar', 'Export a calendar as iCal format string.', {
+        calendarId: z.string().describe('The calendar identifier'),
+    }, async (args) => {
+        const calendar = calendars.get(args.calendarId);
+        if (!calendar) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: `Calendar "${args.calendarId}" not found`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: calendar.toString(),
+                },
+            ],
+        };
+    });
+}
+/**
+ * Load calendars from environment variables
+ * Supports ICAL_URL, ICAL_FILE, or ICAL_CALENDARS (JSON array)
+ */
+async function loadCalendarsFromEnv() {
+    // Single calendar from URL
+    const icalUrl = process.env.ICAL_URL;
+    if (icalUrl) {
+        try {
+            const calendar = await loadCalendar(icalUrl);
+            const alias = process.env.ICAL_ALIAS || 'default';
+            calendars.set(alias, calendar);
+            console.error(`Loaded calendar "${alias}" from ${icalUrl}`);
+        }
+        catch (error) {
+            console.error(`Failed to load calendar from ICAL_URL: ${error}`);
+        }
+    }
+    // Single calendar from file
+    const icalFile = process.env.ICAL_FILE;
+    if (icalFile) {
+        try {
+            const calendar = await loadCalendar(icalFile);
+            const alias = process.env.ICAL_ALIAS || 'default';
+            calendars.set(alias, calendar);
+            console.error(`Loaded calendar "${alias}" from ${icalFile}`);
+        }
+        catch (error) {
+            console.error(`Failed to load calendar from ICAL_FILE: ${error}`);
+        }
+    }
+    // Multiple calendars from JSON
+    const icalCalendars = process.env.ICAL_CALENDARS;
+    if (icalCalendars) {
+        try {
+            const configs = JSON.parse(icalCalendars);
+            for (const config of configs) {
+                try {
+                    const calendar = await loadCalendar(config.source);
+                    calendars.set(config.alias, calendar);
+                    console.error(`Loaded calendar "${config.alias}" from ${config.source}`);
+                }
+                catch (error) {
+                    console.error(`Failed to load calendar "${config.alias}": ${error}`);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Failed to parse ICAL_CALENDARS: ${error}`);
+        }
+    }
+}
+/**
+ * Main function to run the MCP server
+ */
+async function main() {
+    // Load any calendars configured via environment variables
+    await loadCalendarsFromEnv();
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('iCal MCP Server running on stdio');
+}
+// Run the server
+main().catch((error) => {
+    console.error('Fatal error in main():', error);
+    process.exit(1);
+});
+// Export for testing
+export { calendars };
+//# sourceMappingURL=index.js.map