digital-tools 2.0.2 → 2.1.1

package/src/providers/video-conferencing/google-meet.js

@@ -0,0 +1,286 @@
+/**
+ * Google Meet Video Conferencing Provider
+ *
+ * Concrete implementation of VideoConferencingProvider using Google Calendar API v3
+ * to create and manage Google Meet video conferences.
+ *
+ * @packageDocumentation
+ */
+import { defineProvider } from '../registry.js';
+const CALENDAR_API_URL = 'https://www.googleapis.com/calendar/v3';
+/**
+ * Google Meet provider info
+ */
+export const googleMeetInfo = {
+    id: 'meeting.google-meet',
+    name: 'Google Meet',
+    description: 'Google Meet video conferencing via Google Calendar API',
+    category: 'video-conferencing',
+    website: 'https://meet.google.com',
+    docsUrl: 'https://developers.google.com/calendar/api',
+    requiredConfig: ['accessToken'],
+    optionalConfig: ['clientId', 'clientSecret', 'refreshToken'],
+};
+/**
+ * Create Google Meet provider
+ */
+export function createGoogleMeetProvider(config) {
+    let accessToken;
+    let clientId;
+    let clientSecret;
+    let refreshToken;
+    let tokenExpiresAt = 0;
+    let calendarId = 'primary';
+    /**
+     * Refresh OAuth access token
+     */
+    async function refreshAccessToken() {
+        if (!clientId || !clientSecret || !refreshToken) {
+            throw new Error('clientId, clientSecret, and refreshToken required for token refresh');
+        }
+        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: refreshToken,
+                grant_type: 'refresh_token',
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to refresh access token: HTTP ${response.status}`);
+        }
+        const data = (await response.json());
+        accessToken = data.access_token;
+        tokenExpiresAt = Date.now() + data.expires_in * 1000;
+        return accessToken;
+    }
+    /**
+     * Get valid access token
+     */
+    async function getAccessToken() {
+        // Return cached token if still valid (with 5-minute buffer)
+        if (accessToken && Date.now() < tokenExpiresAt - 300000) {
+            return accessToken;
+        }
+        // Try to refresh if we have refresh token
+        if (refreshToken) {
+            return refreshAccessToken();
+        }
+        // Otherwise use the provided token
+        return accessToken;
+    }
+    /**
+     * Make authenticated API request
+     */
+    async function apiRequest(endpoint, options = {}) {
+        const token = await getAccessToken();
+        const url = `${CALENDAR_API_URL}${endpoint}`;
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                ...options.headers,
+            },
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(`Google Calendar API error: ${response.status} - ${errorData?.error?.message || response.statusText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Convert Google Calendar event to MeetingData
+     */
+    function convertEvent(event) {
+        const startTime = new Date(event.start.dateTime);
+        const endTime = new Date(event.end.dateTime);
+        const duration = Math.round((endTime.getTime() - startTime.getTime()) / 60000); // minutes
+        return {
+            id: event.id,
+            topic: event.summary,
+            startTime,
+            duration,
+            timezone: event.start.timeZone,
+            agenda: event.description,
+            joinUrl: event.hangoutLink || event.conferenceData?.entryPoints?.[0]?.uri || '',
+            hostId: event.creator?.id || event.creator?.email || '',
+            status: event.status === 'confirmed' ? 'waiting' : 'finished',
+            createdAt: new Date(event.created),
+        };
+    }
+    return {
+        info: googleMeetInfo,
+        async initialize(cfg) {
+            accessToken = cfg.accessToken;
+            clientId = cfg.clientId;
+            clientSecret = cfg.clientSecret;
+            refreshToken = cfg.refreshToken;
+            if (!accessToken) {
+                throw new Error('Google Meet requires accessToken');
+            }
+            // Override calendar ID if provided
+            if (cfg.calendarId) {
+                calendarId = cfg.calendarId;
+            }
+        },
+        async healthCheck() {
+            const start = Date.now();
+            try {
+                // Get calendar to verify API access
+                await apiRequest(`/calendars/${calendarId}`);
+                return {
+                    healthy: true,
+                    latencyMs: Date.now() - start,
+                    message: 'Connected',
+                    checkedAt: new Date(),
+                };
+            }
+            catch (error) {
+                return {
+                    healthy: false,
+                    latencyMs: Date.now() - start,
+                    message: error instanceof Error ? error.message : 'Unknown error',
+                    checkedAt: new Date(),
+                };
+            }
+        },
+        async dispose() {
+            // Clear cached token
+            accessToken = '';
+            tokenExpiresAt = 0;
+        },
+        async createMeeting(meeting) {
+            const endTime = meeting.startTime
+                ? new Date(meeting.startTime.getTime() + (meeting.duration || 60) * 60000)
+                : new Date(Date.now() + (meeting.duration || 60) * 60000);
+            const body = {
+                summary: meeting.topic,
+                description: meeting.agenda,
+                start: {
+                    dateTime: (meeting.startTime || new Date()).toISOString(),
+                    timeZone: meeting.timezone || 'UTC',
+                },
+                end: {
+                    dateTime: endTime.toISOString(),
+                    timeZone: meeting.timezone || 'UTC',
+                },
+                conferenceData: {
+                    createRequest: {
+                        requestId: `meet-${Date.now()}`,
+                        conferenceSolutionKey: {
+                            type: 'hangoutsMeet',
+                        },
+                    },
+                },
+            };
+            const response = await apiRequest(`/calendars/${calendarId}/events?conferenceDataVersion=1`, {
+                method: 'POST',
+                body: JSON.stringify(body),
+            });
+            return convertEvent(response);
+        },
+        async getMeeting(meetingId) {
+            try {
+                const response = await apiRequest(`/calendars/${calendarId}/events/${meetingId}`);
+                return convertEvent(response);
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes('404')) {
+                    return null;
+                }
+                throw error;
+            }
+        },
+        async updateMeeting(meetingId, updates) {
+            // First get the current event
+            const current = await this.getMeeting(meetingId);
+            if (!current) {
+                throw new Error(`Meeting ${meetingId} not found`);
+            }
+            const body = {};
+            if (updates.topic)
+                body.summary = updates.topic;
+            if (updates.agenda !== undefined)
+                body.description = updates.agenda;
+            if (updates.startTime) {
+                const endTime = new Date(updates.startTime.getTime() + (updates.duration || current.duration || 60) * 60000);
+                body.start = {
+                    dateTime: updates.startTime.toISOString(),
+                    timeZone: updates.timezone || current.timezone || 'UTC',
+                };
+                body.end = {
+                    dateTime: endTime.toISOString(),
+                    timeZone: updates.timezone || current.timezone || 'UTC',
+                };
+            }
+            const response = await apiRequest(`/calendars/${calendarId}/events/${meetingId}`, {
+                method: 'PATCH',
+                body: JSON.stringify(body),
+            });
+            return convertEvent(response);
+        },
+        async deleteMeeting(meetingId) {
+            try {
+                await apiRequest(`/calendars/${calendarId}/events/${meetingId}`, {
+                    method: 'DELETE',
+                });
+                return true;
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes('404')) {
+                    return false;
+                }
+                throw error;
+            }
+        },
+        async listMeetings(options = {}) {
+            const params = new URLSearchParams();
+            // Set time range based on type
+            const now = new Date();
+            if (options.type === 'upcoming' || options.type === 'scheduled') {
+                params.append('timeMin', now.toISOString());
+            }
+            else if (options.type === 'previous') {
+                params.append('timeMax', now.toISOString());
+            }
+            params.append('singleEvents', 'true');
+            params.append('orderBy', 'startTime');
+            if (options.limit)
+                params.append('maxResults', options.limit.toString());
+            if (options.cursor)
+                params.append('pageToken', options.cursor);
+            const response = await apiRequest(`/calendars/${calendarId}/events?${params.toString()}`);
+            // Filter to only events with Meet links
+            const meetEvents = response.items.filter((event) => event.hangoutLink || event.conferenceData);
+            return {
+                items: meetEvents.map(convertEvent),
+                hasMore: !!response.nextPageToken,
+                nextCursor: response.nextPageToken,
+            };
+        },
+        endMeeting: async function (meetingId) {
+            // Google Meet doesn't support programmatically ending meetings
+            // We can delete the calendar event instead
+            return await this.deleteMeeting(meetingId);
+        },
+        async getParticipants(meetingId) {
+            // Google Calendar API doesn't provide participant data for past meetings
+            // This would require Google Meet API access which is more restricted
+            return [];
+        },
+        async getRecordings(meetingId) {
+            // Google Meet recordings are stored in Google Drive
+            // This would require Google Drive API access
+            return [];
+        },
+    };
+}
+/**
+ * Google Meet provider definition
+ */
+export const googleMeetProvider = defineProvider(googleMeetInfo, async (config) => createGoogleMeetProvider(config));

package/src/providers/video-conferencing/index.js

@@ -0,0 +1,31 @@
+/**
+ * Video Conferencing Providers
+ *
+ * @packageDocumentation
+ */
+export { zoomInfo, zoomProvider, createZoomProvider } from './zoom.js';
+export { googleMeetInfo, googleMeetProvider, createGoogleMeetProvider } from './google-meet.js';
+export { teamsInfo, teamsProvider, createTeamsProvider } from './teams.js';
+export { jitsiInfo, jitsiProvider, createJitsiProvider } from './jitsi.js';
+import { zoomProvider } from './zoom.js';
+import { googleMeetProvider } from './google-meet.js';
+import { teamsProvider } from './teams.js';
+import { jitsiProvider } from './jitsi.js';
+/**
+ * Register all video conferencing providers
+ */
+export function registerVideoConferencingProviders() {
+    zoomProvider.register();
+    googleMeetProvider.register();
+    teamsProvider.register();
+    jitsiProvider.register();
+}
+/**
+ * All video conferencing providers
+ */
+export const videoConferencingProviders = [
+    zoomProvider,
+    googleMeetProvider,
+    teamsProvider,
+    jitsiProvider,
+];

package/src/providers/video-conferencing/jitsi.js

@@ -0,0 +1,254 @@
+/**
+ * Jitsi Meet Video Conferencing Provider
+ *
+ * Concrete implementation of VideoConferencingProvider using Jitsi Meet.
+ * Self-hostable open source video conferencing solution.
+ *
+ * @packageDocumentation
+ */
+import { defineProvider } from '../registry.js';
+const DEFAULT_JITSI_SERVER = 'https://meet.jit.si';
+/**
+ * Jitsi Meet provider info
+ */
+export const jitsiInfo = {
+    id: 'meeting.jitsi',
+    name: 'Jitsi Meet',
+    description: 'Open source self-hostable video conferencing solution',
+    category: 'video-conferencing',
+    website: 'https://jitsi.org',
+    docsUrl: 'https://jitsi.github.io/handbook/docs/devops-guide/devops-guide-docker',
+    requiredConfig: [],
+    optionalConfig: ['serverUrl', 'jwtSecret'],
+};
+/**
+ * Create Jitsi Meet provider
+ */
+export function createJitsiProvider(config) {
+    let serverUrl;
+    let jwtSecret;
+    let hostId;
+    // In-memory storage for meetings
+    const meetings = new Map();
+    /**
+     * Generate a unique room name
+     */
+    function generateRoomName(topic) {
+        // Create URL-safe room name from topic
+        const safeTopic = topic
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-+|-+$/g, '')
+            .substring(0, 50);
+        // Add random suffix to ensure uniqueness
+        const randomSuffix = Math.random().toString(36).substring(2, 8);
+        return `${safeTopic}-${randomSuffix}`;
+    }
+    /**
+     * Generate JWT token for secure Jitsi meeting (if JWT is enabled)
+     */
+    function generateJWT(roomName, moderator = true) {
+        if (!jwtSecret) {
+            return undefined;
+        }
+        // Note: In production, you would use a proper JWT library
+        // This is a simplified placeholder
+        // In real implementation, use jsonwebtoken package
+        const header = {
+            alg: 'HS256',
+            typ: 'JWT',
+        };
+        const payload = {
+            context: {
+                user: {
+                    moderator,
+                    id: hostId,
+                },
+            },
+            aud: 'jitsi',
+            iss: 'jitsi',
+            sub: serverUrl.replace(/^https?:\/\//, ''),
+            room: roomName,
+            exp: Math.floor(Date.now() / 1000) + 3600, // 1 hour expiry
+        };
+        // This is a placeholder - in real implementation use proper JWT signing
+        return `${btoa(JSON.stringify(header))}.${btoa(JSON.stringify(payload))}.signature`;
+    }
+    /**
+     * Build join URL for a Jitsi room
+     */
+    function buildJoinUrl(roomName, jwt) {
+        let url = `${serverUrl}/${roomName}`;
+        if (jwt) {
+            url += `?jwt=${jwt}`;
+        }
+        return url;
+    }
+    /**
+     * Convert stored meeting to MeetingData
+     */
+    function convertMeeting(meeting) {
+        return {
+            id: meeting.id,
+            topic: meeting.topic,
+            startTime: meeting.startTime,
+            duration: meeting.duration,
+            timezone: meeting.timezone,
+            agenda: meeting.agenda,
+            joinUrl: meeting.joinUrl,
+            hostId: meeting.hostId,
+            status: meeting.status,
+            password: meeting.password,
+            createdAt: meeting.createdAt,
+        };
+    }
+    return {
+        info: jitsiInfo,
+        async initialize(cfg) {
+            serverUrl = cfg.serverUrl || DEFAULT_JITSI_SERVER;
+            jwtSecret = cfg.jwtSecret;
+            hostId = cfg.hostId || 'default-host';
+            // Remove trailing slash from server URL
+            serverUrl = serverUrl.replace(/\/$/, '');
+        },
+        async healthCheck() {
+            const start = Date.now();
+            try {
+                // Check if Jitsi server is accessible
+                const response = await fetch(serverUrl, {
+                    method: 'HEAD',
+                });
+                if (!response.ok && response.status !== 404) {
+                    throw new Error(`Server returned status ${response.status}`);
+                }
+                return {
+                    healthy: true,
+                    latencyMs: Date.now() - start,
+                    message: 'Connected',
+                    checkedAt: new Date(),
+                };
+            }
+            catch (error) {
+                return {
+                    healthy: false,
+                    latencyMs: Date.now() - start,
+                    message: error instanceof Error ? error.message : 'Unknown error',
+                    checkedAt: new Date(),
+                };
+            }
+        },
+        async dispose() {
+            // Clear all stored meetings
+            meetings.clear();
+        },
+        async createMeeting(meeting) {
+            const id = `jitsi-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+            const roomName = generateRoomName(meeting.topic);
+            const jwt = generateJWT(roomName, true);
+            const joinUrl = buildJoinUrl(roomName, jwt);
+            const storedMeeting = {
+                id,
+                topic: meeting.topic,
+                startTime: meeting.startTime,
+                duration: meeting.duration,
+                timezone: meeting.timezone,
+                agenda: meeting.agenda,
+                joinUrl,
+                hostId,
+                status: 'waiting',
+                password: meeting.password,
+                createdAt: new Date(),
+                roomName,
+            };
+            meetings.set(id, storedMeeting);
+            return convertMeeting(storedMeeting);
+        },
+        async getMeeting(meetingId) {
+            const meeting = meetings.get(meetingId);
+            return meeting ? convertMeeting(meeting) : null;
+        },
+        async updateMeeting(meetingId, updates) {
+            const meeting = meetings.get(meetingId);
+            if (!meeting) {
+                throw new Error(`Meeting ${meetingId} not found`);
+            }
+            // Update meeting properties
+            if (updates.topic)
+                meeting.topic = updates.topic;
+            if (updates.startTime !== undefined)
+                meeting.startTime = updates.startTime;
+            if (updates.duration !== undefined)
+                meeting.duration = updates.duration;
+            if (updates.timezone !== undefined)
+                meeting.timezone = updates.timezone;
+            if (updates.agenda !== undefined)
+                meeting.agenda = updates.agenda;
+            if (updates.password !== undefined)
+                meeting.password = updates.password;
+            // If topic changed, regenerate room name and URL
+            if (updates.topic) {
+                meeting.roomName = generateRoomName(updates.topic);
+                const jwt = generateJWT(meeting.roomName, true);
+                meeting.joinUrl = buildJoinUrl(meeting.roomName, jwt);
+            }
+            meetings.set(meetingId, meeting);
+            return convertMeeting(meeting);
+        },
+        async deleteMeeting(meetingId) {
+            return meetings.delete(meetingId);
+        },
+        async listMeetings(options = {}) {
+            let items = Array.from(meetings.values());
+            // Filter by type
+            const now = new Date();
+            if (options.type === 'upcoming' || options.type === 'scheduled') {
+                items = items.filter((m) => m.startTime && m.startTime > now);
+            }
+            else if (options.type === 'previous') {
+                items = items.filter((m) => m.startTime && m.startTime < now);
+            }
+            else if (options.type === 'live') {
+                items = items.filter((m) => m.status === 'started');
+            }
+            // Sort by start time
+            items.sort((a, b) => {
+                const aTime = a.startTime?.getTime() || 0;
+                const bTime = b.startTime?.getTime() || 0;
+                return aTime - bTime;
+            });
+            // Apply pagination
+            const offset = parseInt(options.cursor || '0', 10);
+            const limit = options.limit || 50;
+            const paginatedItems = items.slice(offset, offset + limit);
+            return {
+                items: paginatedItems.map(convertMeeting),
+                hasMore: offset + limit < items.length,
+                nextCursor: offset + limit < items.length ? (offset + limit).toString() : undefined,
+            };
+        },
+        async endMeeting(meetingId) {
+            const meeting = meetings.get(meetingId);
+            if (!meeting) {
+                return false;
+            }
+            meeting.status = 'finished';
+            meetings.set(meetingId, meeting);
+            return true;
+        },
+        async getParticipants(meetingId) {
+            // Jitsi doesn't provide a built-in API for participant data
+            // This would require setting up Jitsi Meet API with prosody modules
+            // or integrating with jitsi-videobridge stats
+            return [];
+        },
+        async getRecordings(meetingId) {
+            // Jitsi recordings would need to be configured with Jibri
+            // and would require integration with your recording storage
+            return [];
+        },
+    };
+}
+/**
+ * Jitsi Meet provider definition
+ */
+export const jitsiProvider = defineProvider(jitsiInfo, async (config) => createJitsiProvider(config));