digital-tools 2.1.1 → 2.3.0

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

@@ -1,286 +0,0 @@
-/**
- * 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

@@ -1,31 +0,0 @@
-/**
- * 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

@@ -1,254 +0,0 @@
-/**
- * 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));