@luckydye/calendar 1.1.1 → 1.1.3

package/src/GoogleCalendarSource.ts

@@ -0,0 +1,710 @@
+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 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;
+}
+
+/**
+ * Google Calendar API colors response.
+ */
+interface GoogleCalendarColors {
+  event: Record<string, {
+    background: string;
+    foreground: string;
+  }>;
+}
+
+/**
+ * Google Calendar source for syncing with Google Calendar API.
+ *
+ * @example
+ * const source = new GoogleCalendarSource(
+ *   'google-1',
+ *   'My Google Calendar',
+ *   '#4285F4',
+ *   {
+ *     accessToken: 'ya29.a0AfH6SMB...',
+ *     calendarId: 'primary'
+ *   }
+ * );
+ *
+ * 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 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, '');
+}
+
+/**
+ * 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, '');
+}
+
+/**
+ * Helper function to initiate Google OAuth2 authentication using PKCE flow.
+ *
+ * @param clientId - Google OAuth2 client ID
+ * @param clientSecret - Google OAuth2 client secret (for Desktop app credentials)
+ * @param scopes - OAuth scopes to request (defaults to calendar read/write)
+ * @returns Promise resolving to OAuth tokens
+ *
+ * @example
+ * const tokens = await authenticateWithGoogle(
+ *   'your-client-id.apps.googleusercontent.com',
+ *   'your-client-secret'
+ * );
+ * const source = new GoogleCalendarSource('google-1', 'My Calendar', '#4285F4', {
+ *   accessToken: tokens.accessToken,
+ *   refreshToken: tokens.refreshToken,
+ *   tokenExpiry: tokens.expiry,
+ * });
+ */
+export async function authenticateWithGoogle(
+  clientId: string,
+  clientSecret: string,
+  scopes: string[] = ['https://www.googleapis.com/auth/calendar']
+): Promise<{
+  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);
+  });
+}