@luckydye/calendar 1.3.1 → 1.4.0

package/src/GoogleCalendarSource.ts

@@ -1,69 +1,75 @@
+import type {
+	CalendarCredentials,
+	CalendarSource,
+} from "./CalendarIntegration.js";
 import type { CalendarEvent } from "./CalendarInternal.js";
-import type { CalendarSource, CalendarCredentials } from "./CalendarIntegration.js";
 
 /**
  * Google Calendar API credentials.
  */
 export interface GoogleCredentials extends CalendarCredentials {
-  /**
-   * Google OAuth2 access token
-   */
-  accessToken: string;
-  /**
-   * Google OAuth2 refresh token (optional, for token refresh)
-   */
-  refreshToken?: string;
-  /**
-   * Token expiry timestamp (ISO string)
-   */
-  tokenExpiry?: string;
-  /**
-   * Google Calendar ID (default: 'primary')
-   */
-  calendarId?: string;
+	/**
+	 * Google OAuth2 access token
+	 */
+	accessToken: string;
+	/**
+	 * Google OAuth2 refresh token (optional, for token refresh)
+	 */
+	refreshToken?: string;
+	/**
+	 * Token expiry timestamp (ISO string)
+	 */
+	tokenExpiry?: string;
+	/**
+	 * Google Calendar ID (default: 'primary')
+	 */
+	calendarId?: string;
 }
 
 /**
  * Google Calendar API event response structure.
  */
 interface GoogleCalendarEvent {
-  id: string;
-  summary?: string;
-  description?: string;
-  location?: string;
-  start?: {
-    dateTime?: string;
-    date?: string;
-  };
-  end?: {
-    dateTime?: string;
-    date?: string;
-  };
-  colorId?: string;
-  recurringEventId?: string;
-  recurrence?: string[];
-  organizer?: {
-    email?: string;
-    displayName?: string;
-  };
-  attendees?: Array<{
-    email?: string;
-    displayName?: string;
-    responseStatus?: string;
-    optional?: boolean;
-  }>;
-  htmlLink?: string;
-  status?: string;
+	id: string;
+	summary?: string;
+	description?: string;
+	location?: string;
+	start?: {
+		dateTime?: string;
+		date?: string;
+	};
+	end?: {
+		dateTime?: string;
+		date?: string;
+	};
+	colorId?: string;
+	recurringEventId?: string;
+	recurrence?: string[];
+	organizer?: {
+		email?: string;
+		displayName?: string;
+	};
+	attendees?: Array<{
+		email?: string;
+		displayName?: string;
+		responseStatus?: string;
+		optional?: boolean;
+	}>;
+	htmlLink?: string;
+	status?: string;
 }
 
 /**
  * Google Calendar API colors response.
  */
 interface GoogleCalendarColors {
-  event: Record<string, {
-    background: string;
-    foreground: string;
-  }>;
+	event: Record<
+		string,
+		{
+			background: string;
+			foreground: string;
+		}
+	>;
 }
 
 /**
@@ -83,506 +89,578 @@ interface GoogleCalendarColors {
  * const events = await source.fetchEvents();
  */
 export class GoogleCalendarSource implements CalendarSource {
-  readonly type = 'google';
-  credentials: GoogleCredentials;
-  enabled: boolean;
-
-  /**
-   * Google Calendar color mapping to hex colors
-   */
-  private static readonly GOOGLE_COLORS: Record<string, string> = {
-    '1': '#7986cb',  // Lavender
-    '2': '#33b679',  // Sage
-    '3': '#8e24aa',  // Grape
-    '4': '#e67c73',  // Flamingo
-    '5': '#f6c026',  // Banana
-    '6': '#f5511d',  // Tangerine
-    '7': '#039be5',  // Peacock
-    '8': '#616161',  // Graphite
-    '9': '#3f51b5',  // Blueberry
-    '10': '#0b8043', // Basil
-    '11': '#d60000', // Tomato
-  };
-
-  constructor(
-    public id: string,
-    public name: string,
-    public color: string,
-    credentials: GoogleCredentials,
-    enabled = true
-  ) {
-    this.credentials = credentials;
-    this.enabled = enabled;
-  }
-
-  /**
-   * Get the Google Calendar ID (defaults to 'primary').
-   */
-  private get calendarId(): string {
-    return this.credentials.calendarId || 'primary';
-  }
-
-  /**
-   * Check if the access token needs refresh.
-   */
-  private needsTokenRefresh(): boolean {
-    if (!this.credentials.tokenExpiry) return false;
-    const expiry = new Date(this.credentials.tokenExpiry);
-    return expiry.getTime() - Date.now() < 5 * 60 * 1000; // Refresh if < 5 min
-  }
-
-  /**
-   * Cached client credentials from public/credentials_google.json
-   */
-  private static clientCredentials: { clientId: string; clientSecret: string } | null = null;
-
-  /**
-   * Fetch client credentials from public directory.
-   */
-  private static async fetchClientCredentials(): Promise<{ clientId: string; clientSecret: string }> {
-    if (GoogleCalendarSource.clientCredentials) {
-      return GoogleCalendarSource.clientCredentials;
-    }
-
-    const response = await fetch('/credentials_google.json');
-    if (!response.ok) {
-      throw new Error('Failed to load Google client credentials from public/credentials_google.json');
-    }
-
-    const data = await response.json();
-    const installed = data.installed || data.web;
-    
-    if (!installed?.client_id || !installed?.client_secret) {
-      throw new Error('Invalid credentials file: missing client_id or client_secret');
-    }
-
-    GoogleCalendarSource.clientCredentials = {
-      clientId: installed.client_id,
-      clientSecret: installed.client_secret,
-    };
-
-    return GoogleCalendarSource.clientCredentials;
-  }
-
-  /**
-   * Refresh the access token using the refresh token.
-   * Throws if no refresh token is available.
-   */
-  private async refreshAccessToken(): Promise<void> {
-    if (!this.credentials.refreshToken) {
-      throw new Error('No refresh token available for Google Calendar');
-    }
-
-    const { clientId, clientSecret } = await GoogleCalendarSource.fetchClientCredentials();
-
-    const response = await fetch('https://oauth2.googleapis.com/token', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/x-www-form-urlencoded',
-      },
-      body: new URLSearchParams({
-        client_id: clientId,
-        client_secret: clientSecret,
-        refresh_token: this.credentials.refreshToken,
-        grant_type: 'refresh_token',
-      }),
-    });
-
-    if (!response.ok) {
-      const errorData = await response.json();
-      throw new Error(`Token refresh failed: ${errorData.error_description || errorData.error}`);
-    }
-
-    const tokens = await response.json();
-    this.credentials.accessToken = tokens.access_token;
-    const expiry = new Date(Date.now() + tokens.expires_in * 1000);
-    this.credentials.tokenExpiry = expiry.toISOString();
-  }
-
-  /**
-   * Get a valid access token, refreshing if necessary.
-   */
-  private async getAccessToken(): Promise<string> {
-    if (this.needsTokenRefresh() && this.credentials.refreshToken) {
-      await this.refreshAccessToken();
-    }
-    return this.credentials.accessToken;
-  }
-
-  /**
-   * Make an authenticated request to the Google Calendar API.
-   */
-  private async apiRequest<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
-    const token = await this.getAccessToken();
-    const baseUrl = 'https://www.googleapis.com/calendar/v3';
-    const url = `${baseUrl}${endpoint}`;
-
-    const response = await fetch(url, {
-      ...options,
-      headers: {
-        Authorization: `Bearer ${token}`,
-        'Content-Type': 'application/json',
-        ...options.headers,
-      },
-    });
-
-    if (!response.ok) {
-      if (response.status === 401) {
-        throw new Error('Google Calendar authentication failed. Please re-authenticate.');
-      }
-      throw new Error(`Google Calendar API error: ${response.status} ${response.statusText}`);
-    }
-
-    return response.json() as Promise<T>;
-  }
-
-  /**
-   * Convert a Google Calendar event to internal CalendarEvent format.
-   */
-  private mapGoogleEvent(event: GoogleCalendarEvent): CalendarEvent | null {
-    if (!event.start || !event.end) return null;
-
-    // Parse start date - for all-day events, parse as local date to avoid UTC shifts
-    let start: Date | null = null;
-    if (event.start.dateTime) {
-      start = new Date(event.start.dateTime);
-    } else if (event.start.date) {
-      const parts = event.start.date.split('-').map(Number);
-      if (parts.length === 3 && parts.every(p => !Number.isNaN(p))) {
-        const [year, month, day] = parts as [number, number, number];
-        start = new Date(year, month - 1, day);
-      }
-    }
-
-    // Parse end date - for all-day events, parse as local date to avoid UTC shifts
-    let end: Date | null = null;
-    if (event.end.dateTime) {
-      end = new Date(event.end.dateTime);
-    } else if (event.end.date) {
-      const parts = event.end.date.split('-').map(Number);
-      if (parts.length === 3 && parts.every(p => !Number.isNaN(p))) {
-        const [year, month, day] = parts as [number, number, number];
-        end = new Date(year, month - 1, day);
-      }
-    }
-
-    if (!start || !end) return null;
-
-    // Detect all-day events: Google uses 'date' instead of 'dateTime' for all-day events
-    const isAllDay = !!event.start?.date && !event.start?.dateTime;
-
-    const eventColor = event.colorId
-      ? GoogleCalendarSource.GOOGLE_COLORS[event.colorId]
-      : undefined;
-
-    const organizer: CalendarEvent['organizer'] = event.organizer?.email
-      ? {
-          email: event.organizer.email,
-          name: event.organizer.displayName,
-        }
-      : undefined;
-
-    const attendees: CalendarEvent['attendees'] = event.attendees?.map(att => ({
-      email: att.email || '',
-      name: att.displayName,
-      role: att.optional ? 'OPT-PARTICIPANT' : 'REQ-PARTICIPANT',
-      status: this.mapGoogleResponseStatus(att.responseStatus),
-    })).filter(att => att.email);
-
-    return {
-      id: event.id,
-      title: event.summary || 'Untitled Event',
-      start,
-      end,
-      isAllDay,
-      color: eventColor || this.color,
-      calendar: this.name,
-      calendarId: this.id,
-      sourceId: this.id,
-      description: event.description,
-      location: event.location,
-      url: event.htmlLink,
-      rrule: event.recurrence?.[0] || undefined,
-      readOnly: false,
-      organizer,
-      attendees,
-    };
-  }
-
-  /**
-   * Map Google Calendar response status to internal status.
-   */
-  private mapGoogleResponseStatus(status?: string): CalendarEvent['attendees'][number]['status'] {
-    switch (status) {
-      case 'accepted': return 'ACCEPTED';
-      case 'declined': return 'DECLINED';
-      case 'tentative': return 'TENTATIVE';
-      default: return 'NEEDS-ACTION';
-    }
-  }
-
-  /**
-   * Map internal response status to Google Calendar status.
-   */
-  private mapToGoogleResponseStatus(status?: CalendarEvent['attendees'][number]['status']): string {
-    switch (status) {
-      case 'ACCEPTED': return 'accepted';
-      case 'DECLINED': return 'declined';
-      case 'TENTATIVE': return 'tentative';
-      default: return 'needsAction';
-    }
-  }
-
-  /**
-   * Format a Date for Google Calendar API (ISO 8601).
-   */
-  private formatDateTime(date: Date): string {
-    return date.toISOString();
-  }
-
-  /**
-   * Convert internal CalendarEvent to Google Calendar event format.
-   */
-  private mapToGoogleEvent(event: Omit<CalendarEvent, 'calendar' | 'color'>): object {
-    const googleEvent: Record<string, unknown> = {
-      summary: event.title,
-      start: {
-        dateTime: this.formatDateTime(event.start),
-      },
-      end: {
-        dateTime: this.formatDateTime(event.end),
-      },
-    };
-
-    if (event.description) {
-      googleEvent.description = event.description;
-    }
-
-    if (event.location) {
-      googleEvent.location = event.location;
-    }
-
-    if (event.attendees && event.attendees.length > 0) {
-      googleEvent.attendees = event.attendees.map(att => ({
-        email: att.email,
-        displayName: att.name,
-        responseStatus: this.mapToGoogleResponseStatus(att.status),
-        optional: att.role === 'OPT-PARTICIPANT',
-      }));
-    }
-
-    return googleEvent;
-  }
-
-  /**
-   * Fetch events from Google Calendar.
-   * Fetches events from 1 year ago to 1 year in the future.
-   */
-  async fetchEvents(): Promise<CalendarEvent[]> {
-    if (!this.enabled) return [];
-
-    const now = new Date();
-    const oneYearAgo = new Date(now.getTime() - 365 * 24 * 60 * 60 * 1000);
-    const oneYearFuture = new Date(now.getTime() + 365 * 24 * 60 * 60 * 1000);
-
-    const params = new URLSearchParams({
-      timeMin: oneYearAgo.toISOString(),
-      timeMax: oneYearFuture.toISOString(),
-      singleEvents: 'true',
-      orderBy: 'startTime',
-      maxResults: '2500',
-    });
-
-    const response = await this.apiRequest<{
-      items: GoogleCalendarEvent[];
-    }>(`/calendars/${encodeURIComponent(this.calendarId)}/events?${params}`);
-
-    if (!response.items) return [];
-
-    return response.items
-      .map(event => this.mapGoogleEvent(event))
-      .filter((event): event is CalendarEvent => event !== null);
-  }
-
-  /**
-   * Create a new event in Google Calendar.
-   */
-  async createEvent(event: Omit<CalendarEvent, 'calendar' | 'color'>): Promise<CalendarEvent> {
-    const googleEvent = this.mapToGoogleEvent(event);
-
-    const response = await this.apiRequest<GoogleCalendarEvent>(
-      `/calendars/${encodeURIComponent(this.calendarId)}/events`,
-      {
-        method: 'POST',
-        body: JSON.stringify(googleEvent),
-      }
-    );
-
-    const created = this.mapGoogleEvent(response);
-    if (!created) {
-      throw new Error('Failed to create event: invalid response from Google Calendar');
-    }
-
-    return created;
-  }
-
-  /**
-   * Update an existing event in Google Calendar.
-   */
-  async updateEvent(id: string, updates: Partial<CalendarEvent>): Promise<CalendarEvent> {
-    const isRsvpOnly = Object.keys(updates).length === 1 && updates.attendees !== undefined;
-
-    if (isRsvpOnly) {
-      // PATCH with only attendees — allowed for non-organizers updating their own response status
-      const response = await this.apiRequest<GoogleCalendarEvent>(
-        `/calendars/${encodeURIComponent(this.calendarId)}/events/${encodeURIComponent(id)}`,
-        {
-          method: 'PATCH',
-          body: JSON.stringify({
-            attendees: updates.attendees!.map(att => ({
-              email: att.email,
-              displayName: att.name,
-              responseStatus: this.mapToGoogleResponseStatus(att.status),
-              optional: att.role === 'OPT-PARTICIPANT',
-            })),
-          }),
-        }
-      );
-      const updated = this.mapGoogleEvent(response);
-      if (!updated) {
-        throw new Error('Failed to update event: invalid response from Google Calendar');
-      }
-      return updated;
-    }
-
-    const existing = await this.apiRequest<GoogleCalendarEvent>(
-      `/calendars/${encodeURIComponent(this.calendarId)}/events/${encodeURIComponent(id)}`
-    );
-
-    const updatedEvent: Record<string, unknown> = {
-      summary: updates.title ?? existing.summary,
-      description: updates.description !== undefined ? updates.description : existing.description,
-      location: updates.location !== undefined ? updates.location : existing.location,
-      start: updates.start
-        ? { dateTime: this.formatDateTime(updates.start) }
-        : existing.start,
-      end: updates.end
-        ? { dateTime: this.formatDateTime(updates.end) }
-        : existing.end,
-    };
-
-    if (updates.attendees) {
-      updatedEvent.attendees = updates.attendees.map(att => ({
-        email: att.email,
-        displayName: att.name,
-        responseStatus: this.mapToGoogleResponseStatus(att.status),
-        optional: att.role === 'OPT-PARTICIPANT',
-      }));
-    }
-
-    const response = await this.apiRequest<GoogleCalendarEvent>(
-      `/calendars/${encodeURIComponent(this.calendarId)}/events/${encodeURIComponent(id)}`,
-      {
-        method: 'PUT',
-        body: JSON.stringify(updatedEvent),
-      }
-    );
-
-    const updated = this.mapGoogleEvent(response);
-    if (!updated) {
-      throw new Error('Failed to update event: invalid response from Google Calendar');
-    }
-
-    return updated;
-  }
-
-  /**
-   * Delete an event from Google Calendar.
-   */
-  async deleteEvent(id: string): Promise<void> {
-    const token = await this.getAccessToken();
-    const baseUrl = 'https://www.googleapis.com/calendar/v3';
-    const url = `${baseUrl}/calendars/${encodeURIComponent(this.calendarId)}/events/${encodeURIComponent(id)}`;
-
-    const response = await fetch(url, {
-      method: 'DELETE',
-      headers: {
-        Authorization: `Bearer ${token}`,
-        'Content-Type': 'application/json',
-      },
-    });
-
-    if (!response.ok && response.status !== 410) {
-      if (response.status === 401) {
-        throw new Error('Google Calendar authentication failed. Please re-authenticate.');
-      }
-      throw new Error(`Google Calendar API error: ${response.status} ${response.statusText}`);
-    }
-  }
-
-  /**
-   * Test the connection to Google Calendar.
-   * Returns true if the credentials are valid.
-   */
-  async testConnection(): Promise<boolean> {
-    try {
-      await this.apiRequest<{ summary: string }>(
-        `/calendars/${encodeURIComponent(this.calendarId)}`
-      );
-      return true;
-    } catch (error) {
-      return false;
-    }
-  }
-
-  /**
-   * Get available Google Calendar colors.
-   */
-  static async getAvailableColors(accessToken: string): Promise<Record<string, string>> {
-    const response = await fetch('https://www.googleapis.com/calendar/v3/colors', {
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-      },
-    });
-
-    if (!response.ok) {
-      throw new Error('Failed to fetch Google Calendar colors');
-    }
-
-    const colors: GoogleCalendarColors = await response.json();
-    const colorMap: Record<string, string> = {};
-
-    for (const [id, colorInfo] of Object.entries(colors.event)) {
-      colorMap[id] = colorInfo.background;
-    }
-
-    return colorMap;
-  }
+	readonly type = "google";
+	credentials: GoogleCredentials;
+	enabled: boolean;
+
+	/**
+	 * Google Calendar color mapping to hex colors
+	 */
+	private static readonly GOOGLE_COLORS: Record<string, string> = {
+		"1": "#7986cb", // Lavender
+		"2": "#33b679", // Sage
+		"3": "#8e24aa", // Grape
+		"4": "#e67c73", // Flamingo
+		"5": "#f6c026", // Banana
+		"6": "#f5511d", // Tangerine
+		"7": "#039be5", // Peacock
+		"8": "#616161", // Graphite
+		"9": "#3f51b5", // Blueberry
+		"10": "#0b8043", // Basil
+		"11": "#d60000", // Tomato
+	};
+
+	constructor(
+		public id: string,
+		public name: string,
+		public color: string,
+		credentials: GoogleCredentials,
+		enabled = true,
+	) {
+		this.credentials = credentials;
+		this.enabled = enabled;
+	}
+
+	/**
+	 * Get the Google Calendar ID (defaults to 'primary').
+	 */
+	private get calendarId(): string {
+		return this.credentials.calendarId || "primary";
+	}
+
+	/**
+	 * Check if the access token needs refresh.
+	 */
+	private needsTokenRefresh(): boolean {
+		if (!this.credentials.tokenExpiry) return false;
+		const expiry = new Date(this.credentials.tokenExpiry);
+		return expiry.getTime() - Date.now() < 5 * 60 * 1000; // Refresh if < 5 min
+	}
+
+	/**
+	 * Cached client credentials from public/credentials_google.json
+	 */
+	private static clientCredentials: {
+		clientId: string;
+		clientSecret: string;
+	} | null = null;
+
+	/**
+	 * Fetch client credentials from public directory.
+	 */
+	private static async fetchClientCredentials(): Promise<{
+		clientId: string;
+		clientSecret: string;
+	}> {
+		if (GoogleCalendarSource.clientCredentials) {
+			return GoogleCalendarSource.clientCredentials;
+		}
+
+		const response = await fetch("/credentials_google.json");
+		if (!response.ok) {
+			throw new Error(
+				"Failed to load Google client credentials from public/credentials_google.json",
+			);
+		}
+
+		const data = await response.json();
+		const installed = data.installed || data.web;
+
+		if (!installed?.client_id || !installed?.client_secret) {
+			throw new Error(
+				"Invalid credentials file: missing client_id or client_secret",
+			);
+		}
+
+		GoogleCalendarSource.clientCredentials = {
+			clientId: installed.client_id,
+			clientSecret: installed.client_secret,
+		};
+
+		return GoogleCalendarSource.clientCredentials;
+	}
+
+	/**
+	 * Refresh the access token using the refresh token.
+	 * Throws if no refresh token is available.
+	 */
+	private async refreshAccessToken(): Promise<void> {
+		if (!this.credentials.refreshToken) {
+			throw new Error("No refresh token available for Google Calendar");
+		}
+
+		const { clientId, clientSecret } =
+			await GoogleCalendarSource.fetchClientCredentials();
+
+		const response = await fetch("https://oauth2.googleapis.com/token", {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/x-www-form-urlencoded",
+			},
+			body: new URLSearchParams({
+				client_id: clientId,
+				client_secret: clientSecret,
+				refresh_token: this.credentials.refreshToken,
+				grant_type: "refresh_token",
+			}),
+		});
+
+		if (!response.ok) {
+			const errorData = await response.json();
+			throw new Error(
+				`Token refresh failed: ${
+					errorData.error_description || errorData.error
+				}`,
+			);
+		}
+
+		const tokens = await response.json();
+		this.credentials.accessToken = tokens.access_token;
+		const expiry = new Date(Date.now() + tokens.expires_in * 1000);
+		this.credentials.tokenExpiry = expiry.toISOString();
+	}
+
+	/**
+	 * Get a valid access token, refreshing if necessary.
+	 */
+	private async getAccessToken(): Promise<string> {
+		if (this.needsTokenRefresh() && this.credentials.refreshToken) {
+			await this.refreshAccessToken();
+		}
+		return this.credentials.accessToken;
+	}
+
+	/**
+	 * Make an authenticated request to the Google Calendar API.
+	 */
+	private async apiRequest<T>(
+		endpoint: string,
+		options: RequestInit = {},
+	): Promise<T> {
+		const token = await this.getAccessToken();
+		const baseUrl = "https://www.googleapis.com/calendar/v3";
+		const url = `${baseUrl}${endpoint}`;
+
+		const response = await fetch(url, {
+			...options,
+			headers: {
+				Authorization: `Bearer ${token}`,
+				"Content-Type": "application/json",
+				...options.headers,
+			},
+		});
+
+		if (!response.ok) {
+			if (response.status === 401) {
+				throw new Error(
+					"Google Calendar authentication failed. Please re-authenticate.",
+				);
+			}
+			throw new Error(
+				`Google Calendar API error: ${response.status} ${response.statusText}`,
+			);
+		}
+
+		return response.json() as Promise<T>;
+	}
+
+	/**
+	 * Convert a Google Calendar event to internal CalendarEvent format.
+	 */
+	private mapGoogleEvent(event: GoogleCalendarEvent): CalendarEvent | null {
+		if (!event.start || !event.end) return null;
+
+		// Parse start date - for all-day events, parse as local date to avoid UTC shifts
+		let start: Date | null = null;
+		if (event.start.dateTime) {
+			start = new Date(event.start.dateTime);
+		} else if (event.start.date) {
+			const parts = event.start.date.split("-").map(Number);
+			if (parts.length === 3 && parts.every((p) => !Number.isNaN(p))) {
+				const [year, month, day] = parts as [number, number, number];
+				start = new Date(year, month - 1, day);
+			}
+		}
+
+		// Parse end date - for all-day events, parse as local date to avoid UTC shifts
+		let end: Date | null = null;
+		if (event.end.dateTime) {
+			end = new Date(event.end.dateTime);
+		} else if (event.end.date) {
+			const parts = event.end.date.split("-").map(Number);
+			if (parts.length === 3 && parts.every((p) => !Number.isNaN(p))) {
+				const [year, month, day] = parts as [number, number, number];
+				end = new Date(year, month - 1, day);
+			}
+		}
+
+		if (!start || !end) return null;
+
+		// Detect all-day events: Google uses 'date' instead of 'dateTime' for all-day events
+		const isAllDay = !!event.start?.date && !event.start?.dateTime;
+
+		const eventColor = event.colorId
+			? GoogleCalendarSource.GOOGLE_COLORS[event.colorId]
+			: undefined;
+
+		const organizer: CalendarEvent["organizer"] = event.organizer?.email
+			? {
+					email: event.organizer.email,
+					name: event.organizer.displayName,
+			  }
+			: undefined;
+
+		const attendees: CalendarEvent["attendees"] = event.attendees
+			?.map((att) => ({
+				email: att.email || "",
+				name: att.displayName,
+				role: att.optional ? "OPT-PARTICIPANT" : "REQ-PARTICIPANT",
+				status: this.mapGoogleResponseStatus(att.responseStatus),
+			}))
+			.filter((att) => att.email);
+
+		return {
+			id: event.id,
+			title: event.summary || "Untitled Event",
+			start,
+			end,
+			isAllDay,
+			color: eventColor || this.color,
+			calendar: this.name,
+			calendarId: this.id,
+			sourceId: this.id,
+			description: event.description,
+			location: event.location,
+			url: event.htmlLink,
+			rrule: event.recurrence?.[0] || undefined,
+			readOnly: false,
+			organizer,
+			attendees,
+		};
+	}
+
+	/**
+	 * Map Google Calendar response status to internal status.
+	 */
+	private mapGoogleResponseStatus(
+		status?: string,
+	): CalendarEvent["attendees"][number]["status"] {
+		switch (status) {
+			case "accepted":
+				return "ACCEPTED";
+			case "declined":
+				return "DECLINED";
+			case "tentative":
+				return "TENTATIVE";
+			default:
+				return "NEEDS-ACTION";
+		}
+	}
+
+	/**
+	 * Map internal response status to Google Calendar status.
+	 */
+	private mapToGoogleResponseStatus(
+		status?: CalendarEvent["attendees"][number]["status"],
+	): string {
+		switch (status) {
+			case "ACCEPTED":
+				return "accepted";
+			case "DECLINED":
+				return "declined";
+			case "TENTATIVE":
+				return "tentative";
+			default:
+				return "needsAction";
+		}
+	}
+
+	/**
+	 * Format a Date for Google Calendar API (ISO 8601).
+	 */
+	private formatDateTime(date: Date): string {
+		return date.toISOString();
+	}
+
+	/**
+	 * Convert internal CalendarEvent to Google Calendar event format.
+	 */
+	private mapToGoogleEvent(
+		event: Omit<CalendarEvent, "calendar" | "color">,
+	): object {
+		const googleEvent: Record<string, unknown> = {
+			summary: event.title,
+			start: {
+				dateTime: this.formatDateTime(event.start),
+			},
+			end: {
+				dateTime: this.formatDateTime(event.end),
+			},
+		};
+
+		if (event.description) {
+			googleEvent.description = event.description;
+		}
+
+		if (event.location) {
+			googleEvent.location = event.location;
+		}
+
+		if (event.attendees && event.attendees.length > 0) {
+			googleEvent.attendees = event.attendees.map((att) => ({
+				email: att.email,
+				displayName: att.name,
+				responseStatus: this.mapToGoogleResponseStatus(att.status),
+				optional: att.role === "OPT-PARTICIPANT",
+			}));
+		}
+
+		return googleEvent;
+	}
+
+	/**
+	 * Fetch events from Google Calendar.
+	 * Fetches events from 1 year ago to 1 year in the future.
+	 */
+	async fetchEvents(): Promise<CalendarEvent[]> {
+		if (!this.enabled) return [];
+
+		const now = new Date();
+		const oneYearAgo = new Date(now.getTime() - 365 * 24 * 60 * 60 * 1000);
+		const oneYearFuture = new Date(now.getTime() + 365 * 24 * 60 * 60 * 1000);
+
+		const params = new URLSearchParams({
+			timeMin: oneYearAgo.toISOString(),
+			timeMax: oneYearFuture.toISOString(),
+			singleEvents: "true",
+			orderBy: "startTime",
+			maxResults: "2500",
+		});
+
+		const response = await this.apiRequest<{
+			items: GoogleCalendarEvent[];
+		}>(`/calendars/${encodeURIComponent(this.calendarId)}/events?${params}`);
+
+		if (!response.items) return [];
+
+		return response.items
+			.map((event) => this.mapGoogleEvent(event))
+			.filter((event): event is CalendarEvent => event !== null);
+	}
+
+	/**
+	 * Create a new event in Google Calendar.
+	 */
+	async createEvent(
+		event: Omit<CalendarEvent, "calendar" | "color">,
+	): Promise<CalendarEvent> {
+		const googleEvent = this.mapToGoogleEvent(event);
+
+		const response = await this.apiRequest<GoogleCalendarEvent>(
+			`/calendars/${encodeURIComponent(this.calendarId)}/events`,
+			{
+				method: "POST",
+				body: JSON.stringify(googleEvent),
+			},
+		);
+
+		const created = this.mapGoogleEvent(response);
+		if (!created) {
+			throw new Error(
+				"Failed to create event: invalid response from Google Calendar",
+			);
+		}
+
+		return created;
+	}
+
+	/**
+	 * Update an existing event in Google Calendar.
+	 */
+	async updateEvent(
+		event: CalendarEvent,
+		updates: Partial<CalendarEvent>,
+	): Promise<CalendarEvent> {
+		const id = event.id;
+		const isRsvpOnly =
+			Object.keys(updates).length === 1 && updates.attendees !== undefined;
+
+		if (isRsvpOnly) {
+			// PATCH with only attendees — allowed for non-organizers updating their own response status
+			const response = await this.apiRequest<GoogleCalendarEvent>(
+				`/calendars/${encodeURIComponent(
+					this.calendarId,
+				)}/events/${encodeURIComponent(id)}`,
+				{
+					method: "PATCH",
+					body: JSON.stringify({
+						attendees: updates.attendees?.map((att) => ({
+							email: att.email,
+							displayName: att.name,
+							responseStatus: this.mapToGoogleResponseStatus(att.status),
+							optional: att.role === "OPT-PARTICIPANT",
+						})),
+					}),
+				},
+			);
+			const updated = this.mapGoogleEvent(response);
+			if (!updated) {
+				throw new Error(
+					"Failed to update event: invalid response from Google Calendar",
+				);
+			}
+			return updated;
+		}
+
+		const existing = await this.apiRequest<GoogleCalendarEvent>(
+			`/calendars/${encodeURIComponent(
+				this.calendarId,
+			)}/events/${encodeURIComponent(id)}`,
+		);
+
+		const updatedEvent: Record<string, unknown> = {
+			summary: updates.title ?? existing.summary,
+			description:
+				updates.description !== undefined
+					? updates.description
+					: existing.description,
+			location:
+				updates.location !== undefined ? updates.location : existing.location,
+			start: updates.start
+				? { dateTime: this.formatDateTime(updates.start) }
+				: existing.start,
+			end: updates.end
+				? { dateTime: this.formatDateTime(updates.end) }
+				: existing.end,
+		};
+
+		if (updates.attendees) {
+			updatedEvent.attendees = updates.attendees.map((att) => ({
+				email: att.email,
+				displayName: att.name,
+				responseStatus: this.mapToGoogleResponseStatus(att.status),
+				optional: att.role === "OPT-PARTICIPANT",
+			}));
+		}
+
+		const response = await this.apiRequest<GoogleCalendarEvent>(
+			`/calendars/${encodeURIComponent(
+				this.calendarId,
+			)}/events/${encodeURIComponent(id)}`,
+			{
+				method: "PUT",
+				body: JSON.stringify(updatedEvent),
+			},
+		);
+
+		const updated = this.mapGoogleEvent(response);
+		if (!updated) {
+			throw new Error(
+				"Failed to update event: invalid response from Google Calendar",
+			);
+		}
+
+		return updated;
+	}
+
+	/**
+	 * Delete an event from Google Calendar.
+	 */
+	async deleteEvent(id: string): Promise<void> {
+		const token = await this.getAccessToken();
+		const baseUrl = "https://www.googleapis.com/calendar/v3";
+		const url = `${baseUrl}/calendars/${encodeURIComponent(
+			this.calendarId,
+		)}/events/${encodeURIComponent(id)}`;
+
+		const response = await fetch(url, {
+			method: "DELETE",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				"Content-Type": "application/json",
+			},
+		});
+
+		if (!response.ok && response.status !== 410) {
+			if (response.status === 401) {
+				throw new Error(
+					"Google Calendar authentication failed. Please re-authenticate.",
+				);
+			}
+			throw new Error(
+				`Google Calendar API error: ${response.status} ${response.statusText}`,
+			);
+		}
+	}
+
+	/**
+	 * Test the connection to Google Calendar.
+	 * Returns true if the credentials are valid.
+	 */
+	async testConnection(): Promise<boolean> {
+		try {
+			await this.apiRequest<{ summary: string }>(
+				`/calendars/${encodeURIComponent(this.calendarId)}`,
+			);
+			return true;
+		} catch (error) {
+			return false;
+		}
+	}
+
+	/**
+	 * Get available Google Calendar colors.
+	 */
+	static async getAvailableColors(
+		accessToken: string,
+	): Promise<Record<string, string>> {
+		const response = await fetch(
+			"https://www.googleapis.com/calendar/v3/colors",
+			{
+				headers: {
+					Authorization: `Bearer ${accessToken}`,
+				},
+			},
+		);
+
+		if (!response.ok) {
+			throw new Error("Failed to fetch Google Calendar colors");
+		}
+
+		const colors: GoogleCalendarColors = await response.json();
+		const colorMap: Record<string, string> = {};
+
+		for (const [id, colorInfo] of Object.entries(colors.event)) {
+			colorMap[id] = colorInfo.background;
+		}
+
+		return colorMap;
+	}
 }
 
 /**
  * Generate a random code verifier for PKCE.
  */
 function generateCodeVerifier(): string {
-  const array = new Uint8Array(32);
-  crypto.getRandomValues(array);
-  return btoa(String.fromCharCode(...array))
-    .replace(/\+/g, '-')
-    .replace(/\//g, '_')
-    .replace(/=/g, '');
+	const array = new Uint8Array(32);
+	crypto.getRandomValues(array);
+	return btoa(String.fromCharCode(...array))
+		.replace(/\+/g, "-")
+		.replace(/\//g, "_")
+		.replace(/=/g, "");
 }
 
 /**
  * Generate a code challenge from a code verifier.
  */
 async function generateCodeChallenge(verifier: string): Promise<string> {
-  const encoder = new TextEncoder();
-  const data = encoder.encode(verifier);
-  const hash = await crypto.subtle.digest('SHA-256', data);
-  return btoa(String.fromCharCode(...new Uint8Array(hash)))
-    .replace(/\+/g, '-')
-    .replace(/\//g, '_')
-    .replace(/=/g, '');
+	const encoder = new TextEncoder();
+	const data = encoder.encode(verifier);
+	const hash = await crypto.subtle.digest("SHA-256", data);
+	return btoa(String.fromCharCode(...new Uint8Array(hash)))
+		.replace(/\+/g, "-")
+		.replace(/\//g, "_")
+		.replace(/=/g, "");
 }
 
 /**
@@ -605,131 +683,150 @@ async function generateCodeChallenge(verifier: string): Promise<string> {
  * });
  */
 export async function authenticateWithGoogle(
-  clientId: string,
-  clientSecret: string,
-  scopes: string[] = ['https://www.googleapis.com/auth/calendar']
+	clientId: string,
+	clientSecret: string,
+	scopes: string[] = ["https://www.googleapis.com/auth/calendar"],
 ): Promise<{
-  accessToken: string;
-  refreshToken?: string;
-  expiry: string;
+	accessToken: string;
+	refreshToken?: string;
+	expiry: string;
 }> {
-  // Use the redirect URI that matches the Desktop app credential configuration
-  const redirectUri = typeof window !== 'undefined'
-    ? window.location.origin
-    : '';
-
-  const state = crypto.randomUUID();
-  const scope = scopes.join(' ');
-
-  // Generate PKCE code verifier and challenge
-  const codeVerifier = generateCodeVerifier();
-  const codeChallenge = await generateCodeChallenge(codeVerifier);
-
-  const params = new URLSearchParams({
-    client_id: clientId,
-    redirect_uri: redirectUri,
-    response_type: 'code',
-    scope: scope,
-    state: state,
-    code_challenge: codeChallenge,
-    code_challenge_method: 'S256',
-    access_type: 'offline',
-    prompt: 'consent',
-  });
-
-  const authUrl = `https://accounts.google.com/o/oauth2/v2/auth?${params}`;
-
-  return new Promise((resolve, reject) => {
-    const popup = window.open(authUrl, 'google-oauth', 'width=500,height=600');
-
-    if (!popup) {
-      reject(new Error('Failed to open OAuth popup. Please allow popups for this site.'));
-      return;
-    }
-
-    const closePopup = () => {
-      try {
-        popup.close();
-      } catch (e) {
-        // Ignore COOP errors when closing popup
-      }
-    };
-
-    const handleMessage = async (event: MessageEvent) => {
-      if (event.origin !== window.location.origin) return;
-
-      if (event.data?.type === 'google-oauth-callback') {
-        clearTimeout(authTimeout);
-        window.removeEventListener('message', handleMessage);
-
-        const { code, error, receivedState } = event.data;
-
-        if (error) {
-          closePopup();
-          reject(new Error(`OAuth error: ${error}`));
-          return;
-        }
-
-        if (receivedState !== state) {
-          closePopup();
-          reject(new Error('OAuth state mismatch'));
-          return;
-        }
-
-        if (!code) {
-          closePopup();
-          reject(new Error('No authorization code received'));
-          return;
-        }
-
-        try {
-          // Exchange code for tokens
-          const tokenResponse = await fetch('https://oauth2.googleapis.com/token', {
-            method: 'POST',
-            headers: {
-              'Content-Type': 'application/x-www-form-urlencoded',
-            },
-            body: new URLSearchParams({
-              client_id: clientId,
-              client_secret: clientSecret,
-              code: code,
-              code_verifier: codeVerifier,
-              grant_type: 'authorization_code',
-              redirect_uri: redirectUri,
-            }),
-          });
-
-          if (!tokenResponse.ok) {
-            const errorData = await tokenResponse.json();
-            closePopup();
-            reject(new Error(`Token exchange failed: ${errorData.error_description || errorData.error}`));
-            return;
-          }
-
-          const tokens = await tokenResponse.json();
-          closePopup();
-
-          const expiry = new Date(Date.now() + tokens.expires_in * 1000);
-
-          resolve({
-            accessToken: tokens.access_token,
-            refreshToken: tokens.refresh_token,
-            expiry: expiry.toISOString(),
-          });
-        } catch (err) {
-          closePopup();
-          reject(err);
-        }
-      }
-    };
-
-    window.addEventListener('message', handleMessage);
-
-    // Timeout after 5 minutes
-    const authTimeout = setTimeout(() => {
-      window.removeEventListener('message', handleMessage);
-      closePopup();
-      reject(new Error('Authentication timeout - window was not closed within 5 minutes'));
-    }, 5 * 60 * 1000);
-  });
+	// Use the redirect URI that matches the Desktop app credential configuration
+	const redirectUri =
+		typeof window !== "undefined" ? window.location.origin : "";
+
+	const state = crypto.randomUUID();
+	const scope = scopes.join(" ");
+
+	// Generate PKCE code verifier and challenge
+	const codeVerifier = generateCodeVerifier();
+	const codeChallenge = await generateCodeChallenge(codeVerifier);
+
+	const params = new URLSearchParams({
+		client_id: clientId,
+		redirect_uri: redirectUri,
+		response_type: "code",
+		scope: scope,
+		state: state,
+		code_challenge: codeChallenge,
+		code_challenge_method: "S256",
+		access_type: "offline",
+		prompt: "consent",
+	});
+
+	const authUrl = `https://accounts.google.com/o/oauth2/v2/auth?${params}`;
+
+	return new Promise((resolve, reject) => {
+		const popup = window.open(authUrl, "google-oauth", "width=500,height=600");
+
+		if (!popup) {
+			reject(
+				new Error(
+					"Failed to open OAuth popup. Please allow popups for this site.",
+				),
+			);
+			return;
+		}
+
+		const closePopup = () => {
+			try {
+				popup.close();
+			} catch (e) {
+				// Ignore COOP errors when closing popup
+			}
+		};
+
+		const handleMessage = async (event: MessageEvent) => {
+			if (event.origin !== window.location.origin) return;
+
+			if (event.data?.type === "google-oauth-callback") {
+				clearTimeout(authTimeout);
+				window.removeEventListener("message", handleMessage);
+
+				const { code, error, receivedState } = event.data;
+
+				if (error) {
+					closePopup();
+					reject(new Error(`OAuth error: ${error}`));
+					return;
+				}
+
+				if (receivedState !== state) {
+					closePopup();
+					reject(new Error("OAuth state mismatch"));
+					return;
+				}
+
+				if (!code) {
+					closePopup();
+					reject(new Error("No authorization code received"));
+					return;
+				}
+
+				try {
+					// Exchange code for tokens
+					const tokenResponse = await fetch(
+						"https://oauth2.googleapis.com/token",
+						{
+							method: "POST",
+							headers: {
+								"Content-Type": "application/x-www-form-urlencoded",
+							},
+							body: new URLSearchParams({
+								client_id: clientId,
+								client_secret: clientSecret,
+								code: code,
+								code_verifier: codeVerifier,
+								grant_type: "authorization_code",
+								redirect_uri: redirectUri,
+							}),
+						},
+					);
+
+					if (!tokenResponse.ok) {
+						const errorData = await tokenResponse.json();
+						closePopup();
+						reject(
+							new Error(
+								`Token exchange failed: ${
+									errorData.error_description || errorData.error
+								}`,
+							),
+						);
+						return;
+					}
+
+					const tokens = await tokenResponse.json();
+					closePopup();
+
+					const expiry = new Date(Date.now() + tokens.expires_in * 1000);
+
+					resolve({
+						accessToken: tokens.access_token,
+						refreshToken: tokens.refresh_token,
+						expiry: expiry.toISOString(),
+					});
+				} catch (err) {
+					closePopup();
+					reject(err);
+				}
+			}
+		};
+
+		window.addEventListener("message", handleMessage);
+
+		// Timeout after 5 minutes
+		const authTimeout = setTimeout(
+			() => {
+				window.removeEventListener("message", handleMessage);
+				closePopup();
+				reject(
+					new Error(
+						"Authentication timeout - window was not closed within 5 minutes",
+					),
+				);
+			},
+			5 * 60 * 1000,
+		);
+	});
 }