createCalendarEvent

Add events to Apple Calendar on macOS by specifying title, dates, calendar, and optional details like location and notes.

Input Schema

TableJSON Schema

Name	Required	Description	Default
`calendarId`	Yes
`title`	Yes
`startDate`	Yes
`endDate`	Yes
`location`	No
`notes`	No

Implementation Reference

src/calendars.ts:127-167 (handler)

Core handler function that formats dates and creates the calendar event via POST to the API bridge endpoint.

export async function createCalendarEvent(
  calendarId: string, 
  title: string, 
  startDate: string, 
  endDate: string, 
  location?: string, 
  notes?: string
): Promise<any> {
  try {
    // Format dates using our flexible date formatter
    const formattedStartDate = formatDate(startDate);
    const formattedEndDate = formatDate(endDate);
    
    if (!formattedStartDate || !formattedEndDate) {
      throw new Error('Invalid date format provided. Please use one of the supported formats.');
    }
    
    // Create the event data
    const eventData: any = {
      title,
      startDate: formattedStartDate,
      endDate: formattedEndDate
    };
    
    // Add optional fields if provided
    if (location) eventData.location = location;
    if (notes) eventData.notes = notes;
    
    
    // Send the request
    const response = await axios.post(
      `${API_BASE_URL}/calendars/${calendarId}/events`, 
      eventData
    );
    
    return response.data;
  } catch (error) {
    console.error(`Failed to create event "${title}" in calendar "${calendarId}":`, error);
    throw new Error(`Failed to create calendar event: ${error}`);
  }
}

src/index.ts:99-106 (schema)

Zod validation schema defining the input parameters for the createCalendarEvent tool.

{ 
  calendarId: z.string(),
  title: z.string(),
  startDate: z.string(),
  endDate: z.string(),
  location: z.string().optional(),
  notes: z.string().optional()
},

src/index.ts:97-160 (registration)

Registers the createCalendarEvent tool with the MCP server, providing name, input schema, and handler function.

server.tool(
  "createCalendarEvent",
  { 
    calendarId: z.string(),
    title: z.string(),
    startDate: z.string(),
    endDate: z.string(),
    location: z.string().optional(),
    notes: z.string().optional()
  },
  async ({ calendarId, title, startDate, endDate, location, notes }) => {
    try {
      try {
        const result = await calendars.createCalendarEvent(
          calendarId, 
          title, 
          startDate, 
          endDate, 
          location, 
          notes
        );
        
        return {
          content: [{ 
            type: "text", 
            text: JSON.stringify({ 
              success: true, 
              message: "Event created", 
              event: result 
            }) 
          }]
        };
      } catch (error: any) {
        // Check if it's a date format error
        if (error.message && (error.message.includes('date') || 
            (error.response?.data?.reason && error.response.data.reason.includes('ISO8601')))) {
          return {
            content: [{ 
              type: "text", 
              text: JSON.stringify({ 
                error: "Failed to create event due to date format issues", 
                message: "The Calendar API requires a specific ISO8601 format that we couldn't determine. The Swift API is expecting a specific format that we haven't been able to match.",
                details: "This is a known issue with the Calendar API Bridge. Please check the API documentation for the correct date format.",
                workaround: "You can try creating events directly through the macOS Calendar app instead."
              }) 
            }],
            isError: true
          };
        }
        
        // If it's not a date format error, rethrow
        throw error;
      }
    } catch (error) {
      return {
        content: [{ 
          type: "text", 
          text: JSON.stringify({ error: "Failed to create event" }) 
        }],
        isError: true
      };
    }
  }
);

src/index.ts:107-159 (handler)

Thin MCP-specific handler wrapper that invokes the core createCalendarEvent function and formats the response for MCP.

async ({ calendarId, title, startDate, endDate, location, notes }) => {
  try {
    try {
      const result = await calendars.createCalendarEvent(
        calendarId, 
        title, 
        startDate, 
        endDate, 
        location, 
        notes
      );
      
      return {
        content: [{ 
          type: "text", 
          text: JSON.stringify({ 
            success: true, 
            message: "Event created", 
            event: result 
          }) 
        }]
      };
    } catch (error: any) {
      // Check if it's a date format error
      if (error.message && (error.message.includes('date') || 
          (error.response?.data?.reason && error.response.data.reason.includes('ISO8601')))) {
        return {
          content: [{ 
            type: "text", 
            text: JSON.stringify({ 
              error: "Failed to create event due to date format issues", 
              message: "The Calendar API requires a specific ISO8601 format that we couldn't determine. The Swift API is expecting a specific format that we haven't been able to match.",
              details: "This is a known issue with the Calendar API Bridge. Please check the API documentation for the correct date format.",
              workaround: "You can try creating events directly through the macOS Calendar app instead."
            }) 
          }],
          isError: true
        };
      }
      
      // If it's not a date format error, rethrow
      throw error;
    }
  } catch (error) {
    return {
      content: [{ 
        type: "text", 
        text: JSON.stringify({ error: "Failed to create event" }) 
      }],
      isError: true
    };
  }
}

MCP Apple Calendars