digital-tools 2.1.1 → 2.3.0

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

@@ -1,270 +0,0 @@
-/**
- * Microsoft Teams Video Conferencing Provider
- *
- * Concrete implementation of VideoConferencingProvider using Microsoft Graph API
- * to create and manage Microsoft Teams online meetings.
- *
- * @packageDocumentation
- */
-import { defineProvider } from '../registry.js';
-const GRAPH_API_URL = 'https://graph.microsoft.com/v1.0';
-/**
- * Microsoft Teams provider info
- */
-export const teamsInfo = {
-    id: 'meeting.teams',
-    name: 'Microsoft Teams',
-    description: 'Microsoft Teams video conferencing via Microsoft Graph API',
-    category: 'video-conferencing',
-    website: 'https://teams.microsoft.com',
-    docsUrl: 'https://docs.microsoft.com/en-us/graph/api/resources/onlinemeeting',
-    requiredConfig: ['accessToken'],
-    optionalConfig: ['clientId', 'clientSecret', 'tenantId'],
-};
-/**
- * Create Microsoft Teams provider
- */
-export function createTeamsProvider(config) {
-    let accessToken;
-    let clientId;
-    let clientSecret;
-    let tenantId;
-    let tokenExpiresAt = 0;
-    let currentUserId;
-    /**
-     * Refresh OAuth access token
-     */
-    async function refreshAccessToken() {
-        if (!clientId || !clientSecret || !tenantId) {
-            throw new Error('clientId, clientSecret, and tenantId required for token refresh');
-        }
-        const response = await fetch(`https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/token`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
-            },
-            body: new URLSearchParams({
-                client_id: clientId,
-                client_secret: clientSecret,
-                scope: 'https://graph.microsoft.com/.default',
-                grant_type: 'client_credentials',
-            }),
-        });
-        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 credentials
-        if (tenantId && clientId && clientSecret) {
-            return refreshAccessToken();
-        }
-        // Otherwise use the provided token
-        return accessToken;
-    }
-    /**
-     * Make authenticated API request
-     */
-    async function apiRequest(endpoint, options = {}) {
-        const token = await getAccessToken();
-        const url = endpoint.startsWith('http') ? endpoint : `${GRAPH_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(`Microsoft Graph API error: ${response.status} - ${errorData?.error?.message || response.statusText}`);
-        }
-        return response.json();
-    }
-    /**
-     * Get current user ID
-     */
-    async function getUserId() {
-        if (currentUserId) {
-            return currentUserId;
-        }
-        const user = await apiRequest('/me');
-        currentUserId = user.id;
-        return currentUserId;
-    }
-    /**
-     * Convert Graph online meeting to MeetingData
-     */
-    function convertMeeting(meeting) {
-        const startTime = new Date(meeting.startDateTime);
-        const endTime = new Date(meeting.endDateTime);
-        const duration = Math.round((endTime.getTime() - startTime.getTime()) / 60000); // minutes
-        return {
-            id: meeting.id,
-            topic: meeting.subject,
-            startTime,
-            duration,
-            joinUrl: meeting.joinWebUrl || meeting.joinUrl || '',
-            hostId: meeting.participants?.organizer?.identity?.user?.id || '',
-            status: 'waiting',
-            createdAt: new Date(meeting.creationDateTime),
-        };
-    }
-    return {
-        info: teamsInfo,
-        async initialize(cfg) {
-            accessToken = cfg.accessToken;
-            clientId = cfg.clientId;
-            clientSecret = cfg.clientSecret;
-            tenantId = cfg.tenantId;
-            if (!accessToken) {
-                throw new Error('Microsoft Teams requires accessToken');
-            }
-        },
-        async healthCheck() {
-            const start = Date.now();
-            try {
-                // Get current user to verify API access
-                await apiRequest('/me');
-                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;
-            currentUserId = undefined;
-        },
-        async createMeeting(meeting) {
-            const userId = await getUserId();
-            const startTime = meeting.startTime || new Date();
-            const endTime = new Date(startTime.getTime() + (meeting.duration || 60) * 60000);
-            const body = {
-                subject: meeting.topic,
-                startDateTime: startTime.toISOString(),
-                endDateTime: endTime.toISOString(),
-                participants: {
-                    attendees: [],
-                },
-            };
-            const response = await apiRequest(`/users/${userId}/onlineMeetings`, {
-                method: 'POST',
-                body: JSON.stringify(body),
-            });
-            return convertMeeting(response);
-        },
-        async getMeeting(meetingId) {
-            try {
-                const userId = await getUserId();
-                const response = await apiRequest(`/users/${userId}/onlineMeetings/${meetingId}`);
-                return convertMeeting(response);
-            }
-            catch (error) {
-                if (error instanceof Error && error.message.includes('404')) {
-                    return null;
-                }
-                throw error;
-            }
-        },
-        async updateMeeting(meetingId, updates) {
-            const userId = await getUserId();
-            // First get the current meeting
-            const current = await this.getMeeting(meetingId);
-            if (!current) {
-                throw new Error(`Meeting ${meetingId} not found`);
-            }
-            const body = {};
-            if (updates.topic)
-                body.subject = updates.topic;
-            if (updates.startTime) {
-                const endTime = new Date(updates.startTime.getTime() + (updates.duration || current.duration || 60) * 60000);
-                body.startDateTime = updates.startTime.toISOString();
-                body.endDateTime = endTime.toISOString();
-            }
-            const response = await apiRequest(`/users/${userId}/onlineMeetings/${meetingId}`, {
-                method: 'PATCH',
-                body: JSON.stringify(body),
-            });
-            return convertMeeting(response);
-        },
-        async deleteMeeting(meetingId) {
-            try {
-                const userId = await getUserId();
-                await apiRequest(`/users/${userId}/onlineMeetings/${meetingId}`, {
-                    method: 'DELETE',
-                });
-                return true;
-            }
-            catch (error) {
-                if (error instanceof Error && error.message.includes('404')) {
-                    return false;
-                }
-                throw error;
-            }
-        },
-        async listMeetings(options = {}) {
-            const userId = await getUserId();
-            const params = new URLSearchParams();
-            if (options.limit)
-                params.append('$top', options.limit.toString());
-            // Note: Graph API doesn't provide easy filtering by time for online meetings
-            // We'll fetch and filter client-side if needed
-            let endpoint = `/users/${userId}/onlineMeetings`;
-            if (params.toString()) {
-                endpoint += `?${params.toString()}`;
-            }
-            // Handle pagination cursor
-            const url = options.cursor || endpoint;
-            const response = await apiRequest(url);
-            return {
-                items: response.value.map(convertMeeting),
-                hasMore: !!response['@odata.nextLink'],
-                nextCursor: response['@odata.nextLink'],
-            };
-        },
-        endMeeting: async function (meetingId) {
-            // Microsoft Teams doesn't support programmatically ending meetings
-            // We can delete the meeting instead
-            return await this.deleteMeeting(meetingId);
-        },
-        async getParticipants(meetingId) {
-            // Microsoft Graph API doesn't provide detailed participant data
-            // This would require Teams Meeting Recording APIs with admin consent
-            return [];
-        },
-        async getRecordings(meetingId) {
-            // Microsoft Teams recordings are stored in OneDrive/SharePoint
-            // This would require additional Graph API calls with different permissions
-            return [];
-        },
-    };
-}
-/**
- * Microsoft Teams provider definition
- */
-export const teamsProvider = defineProvider(teamsInfo, async (config) => createTeamsProvider(config));

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

@@ -1,332 +0,0 @@
-/**
- * Zoom Video Conferencing Provider
- *
- * Concrete implementation of VideoConferencingProvider using Zoom API v2.
- *
- * @packageDocumentation
- */
-import { defineProvider } from '../registry.js';
-const ZOOM_API_URL = 'https://api.zoom.us/v2';
-/**
- * Zoom provider info
- */
-export const zoomInfo = {
-    id: 'video-conferencing.zoom',
-    name: 'Zoom',
-    description: 'Zoom video conferencing and webinar platform',
-    category: 'video-conferencing',
-    website: 'https://zoom.us',
-    docsUrl: 'https://developers.zoom.us/docs/api/',
-    requiredConfig: ['accountId', 'clientId', 'clientSecret'],
-    optionalConfig: ['accessToken'],
-};
-/**
- * Create Zoom video conferencing provider
- */
-export function createZoomProvider(config) {
-    let accountId;
-    let clientId;
-    let clientSecret;
-    let accessToken;
-    let tokenExpiresAt = 0;
-    /**
-     * Get OAuth access token using Server-to-Server OAuth
-     */
-    async function getAccessToken() {
-        // Return cached token if still valid (with 5-minute buffer)
-        if (accessToken && Date.now() < tokenExpiresAt - 300000) {
-            return accessToken;
-        }
-        // Get new token
-        const credentials = Buffer.from(`${clientId}:${clientSecret}`).toString('base64');
-        const response = await fetch(`https://zoom.us/oauth/token?grant_type=account_credentials&account_id=${accountId}`, {
-            method: 'POST',
-            headers: {
-                Authorization: `Basic ${credentials}`,
-                'Content-Type': 'application/x-www-form-urlencoded',
-            },
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to get access token: HTTP ${response.status}`);
-        }
-        const data = (await response.json());
-        accessToken = data.access_token;
-        tokenExpiresAt = Date.now() + data.expires_in * 1000;
-        return accessToken;
-    }
-    /**
-     * Make authenticated API request
-     */
-    async function apiRequest(endpoint, options = {}) {
-        const token = await getAccessToken();
-        const url = `${ZOOM_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(`Zoom API error: ${response.status} - ${errorData?.message || response.statusText}`);
-        }
-        return response.json();
-    }
-    /**
-     * Convert Zoom meeting response to MeetingData
-     */
-    function convertMeeting(meeting) {
-        return {
-            id: meeting.id.toString(),
-            topic: meeting.topic,
-            startTime: meeting.start_time ? new Date(meeting.start_time) : undefined,
-            duration: meeting.duration,
-            timezone: meeting.timezone,
-            agenda: meeting.agenda,
-            joinUrl: meeting.join_url,
-            hostId: meeting.host_id,
-            status: meeting.status,
-            password: meeting.password,
-            createdAt: new Date(meeting.created_at),
-        };
-    }
-    return {
-        info: zoomInfo,
-        async initialize(cfg) {
-            accountId = cfg.accountId;
-            clientId = cfg.clientId;
-            clientSecret = cfg.clientSecret;
-            accessToken = cfg.accessToken;
-            if (!accountId || !clientId || !clientSecret) {
-                throw new Error('Zoom requires accountId, clientId, and clientSecret');
-            }
-        },
-        async healthCheck() {
-            const start = Date.now();
-            try {
-                // Get current user to verify API access
-                await apiRequest('/users/me');
-                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 = undefined;
-            tokenExpiresAt = 0;
-        },
-        async createMeeting(meeting) {
-            const body = {
-                topic: meeting.topic,
-                type: meeting.startTime ? 2 : 1, // 1 = instant, 2 = scheduled
-                ...(meeting.startTime && {
-                    start_time: meeting.startTime.toISOString(),
-                }),
-                ...(meeting.duration && { duration: meeting.duration }),
-                ...(meeting.timezone && { timezone: meeting.timezone }),
-                ...(meeting.agenda && { agenda: meeting.agenda }),
-                ...(meeting.password && { password: meeting.password }),
-            };
-            if (meeting.settings) {
-                body.settings = {
-                    ...(meeting.settings.hostVideo !== undefined && {
-                        host_video: meeting.settings.hostVideo,
-                    }),
-                    ...(meeting.settings.participantVideo !== undefined && {
-                        participant_video: meeting.settings.participantVideo,
-                    }),
-                    ...(meeting.settings.joinBeforeHost !== undefined && {
-                        join_before_host: meeting.settings.joinBeforeHost,
-                    }),
-                    ...(meeting.settings.muteUponEntry !== undefined && {
-                        mute_upon_entry: meeting.settings.muteUponEntry,
-                    }),
-                    ...(meeting.settings.waitingRoom !== undefined && {
-                        waiting_room: meeting.settings.waitingRoom,
-                    }),
-                    ...(meeting.settings.autoRecording && {
-                        auto_recording: meeting.settings.autoRecording,
-                    }),
-                };
-            }
-            const response = await apiRequest('/users/me/meetings', {
-                method: 'POST',
-                body: JSON.stringify(body),
-            });
-            return convertMeeting(response);
-        },
-        async getMeeting(meetingId) {
-            try {
-                const response = await apiRequest(`/meetings/${meetingId}`);
-                return convertMeeting(response);
-            }
-            catch (error) {
-                if (error instanceof Error && error.message.includes('404')) {
-                    return null;
-                }
-                throw error;
-            }
-        },
-        async updateMeeting(meetingId, updates) {
-            const body = {};
-            if (updates.topic)
-                body.topic = updates.topic;
-            if (updates.startTime)
-                body.start_time = updates.startTime.toISOString();
-            if (updates.duration !== undefined)
-                body.duration = updates.duration;
-            if (updates.timezone)
-                body.timezone = updates.timezone;
-            if (updates.agenda !== undefined)
-                body.agenda = updates.agenda;
-            if (updates.password !== undefined)
-                body.password = updates.password;
-            if (updates.settings) {
-                body.settings = {
-                    ...(updates.settings.hostVideo !== undefined && {
-                        host_video: updates.settings.hostVideo,
-                    }),
-                    ...(updates.settings.participantVideo !== undefined && {
-                        participant_video: updates.settings.participantVideo,
-                    }),
-                    ...(updates.settings.joinBeforeHost !== undefined && {
-                        join_before_host: updates.settings.joinBeforeHost,
-                    }),
-                    ...(updates.settings.muteUponEntry !== undefined && {
-                        mute_upon_entry: updates.settings.muteUponEntry,
-                    }),
-                    ...(updates.settings.waitingRoom !== undefined && {
-                        waiting_room: updates.settings.waitingRoom,
-                    }),
-                    ...(updates.settings.autoRecording !== undefined && {
-                        auto_recording: updates.settings.autoRecording,
-                    }),
-                };
-            }
-            await apiRequest(`/meetings/${meetingId}`, {
-                method: 'PATCH',
-                body: JSON.stringify(body),
-            });
-            // Fetch updated meeting
-            const updated = await this.getMeeting(meetingId);
-            if (!updated) {
-                throw new Error(`Failed to fetch updated meeting ${meetingId}`);
-            }
-            return updated;
-        },
-        async deleteMeeting(meetingId) {
-            try {
-                await apiRequest(`/meetings/${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();
-            // Map type option to Zoom API parameter
-            const typeMap = {
-                scheduled: 'scheduled',
-                live: 'live',
-                upcoming: 'upcoming',
-                previous: 'previous_meetings',
-            };
-            if (options.type) {
-                params.append('type', typeMap[options.type] || 'scheduled');
-            }
-            else {
-                params.append('type', 'scheduled');
-            }
-            if (options.limit)
-                params.append('page_size', options.limit.toString());
-            if (options.cursor)
-                params.append('next_page_token', options.cursor);
-            const response = await apiRequest(`/users/me/meetings?${params.toString()}`);
-            return {
-                items: response.meetings.map(convertMeeting),
-                total: response.total_records,
-                hasMore: !!response.next_page_token,
-                nextCursor: response.next_page_token,
-            };
-        },
-        async endMeeting(meetingId) {
-            try {
-                await apiRequest(`/meetings/${meetingId}/status`, {
-                    method: 'PUT',
-                    body: JSON.stringify({ action: 'end' }),
-                });
-                return true;
-            }
-            catch (error) {
-                if (error instanceof Error && error.message.includes('404')) {
-                    return false;
-                }
-                throw error;
-            }
-        },
-        async getParticipants(meetingId) {
-            try {
-                const response = await apiRequest(`/past_meetings/${meetingId}/participants`);
-                return response.participants.map((p) => ({
-                    id: p.id,
-                    name: p.name,
-                    email: p.user_email,
-                    joinTime: new Date(p.join_time),
-                    leaveTime: p.leave_time ? new Date(p.leave_time) : undefined,
-                    duration: p.duration,
-                }));
-            }
-            catch (error) {
-                if (error instanceof Error && error.message.includes('404')) {
-                    return [];
-                }
-                throw error;
-            }
-        },
-        async getRecordings(meetingId) {
-            try {
-                const response = await apiRequest(`/meetings/${meetingId}/recordings`);
-                return response.recording_files.map((r) => ({
-                    id: r.id,
-                    meetingId: r.meeting_id,
-                    type: r.recording_type === 'audio_only' ? 'audio' :
-                        r.file_type === 'TRANSCRIPT' ? 'transcript' : 'video',
-                    url: r.download_url,
-                    size: r.file_size,
-                    duration: undefined, // Not provided in this endpoint
-                    createdAt: new Date(r.recording_start),
-                }));
-            }
-            catch (error) {
-                if (error instanceof Error && error.message.includes('404')) {
-                    return [];
-                }
-                throw error;
-            }
-        },
-    };
-}
-/**
- * Zoom provider definition
- */
-export const zoomProvider = defineProvider(zoomInfo, async (config) => createZoomProvider(config));