digital-tools 2.0.2 → 2.1.1

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

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

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