@auxiora/connector-microsoft 1.0.0

package/dist/connector.js

@@ -0,0 +1,657 @@
+import { defineConnector } from '@auxiora/connectors';
+const GRAPH_BASE = 'https://graph.microsoft.com/v1.0';
+async function graphFetch(token, path, options) {
+    const res = await fetch(`${GRAPH_BASE}${path}`, {
+        method: options?.method ?? 'GET',
+        headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        },
+        body: options?.body ? JSON.stringify(options.body) : undefined,
+    });
+    if (!res.ok) {
+        const err = await res.json().catch(() => ({}));
+        throw new Error(`Graph API error: ${res.status} ${err.error?.message ?? res.statusText}`);
+    }
+    if (res.status === 204)
+        return undefined;
+    return res.json();
+}
+export const microsoftConnector = defineConnector({
+    id: 'microsoft-365',
+    name: 'Microsoft 365',
+    description: 'Integration with Outlook Mail, Calendar, OneDrive, and Contacts via Microsoft Graph API',
+    version: '1.0.0',
+    category: 'productivity',
+    icon: 'microsoft',
+    auth: {
+        type: 'oauth2',
+        oauth2: {
+            authUrl: 'https://login.microsoftonline.com/common/oauth2/v2/authorize',
+            tokenUrl: 'https://login.microsoftonline.com/common/oauth2/v2/token',
+            scopes: [
+                'Mail.ReadWrite',
+                'Mail.Send',
+                'Calendars.ReadWrite',
+                'Contacts.Read',
+                'Files.ReadWrite',
+                'User.Read',
+            ],
+        },
+    },
+    actions: [
+        // --- Mail ---
+        {
+            id: 'mail-list-messages',
+            name: 'List Mail Messages',
+            description: 'List recent emails from Outlook',
+            trustMinimum: 1,
+            trustDomain: 'email',
+            reversible: false,
+            sideEffects: false,
+            params: {
+                folderId: { type: 'string', description: 'Mail folder ID' },
+                maxResults: { type: 'number', description: 'Max messages to return', default: 10 },
+                query: { type: 'string', description: 'OData filter query' },
+            },
+        },
+        {
+            id: 'mail-read-message',
+            name: 'Read Mail Message',
+            description: 'Read a specific email message',
+            trustMinimum: 1,
+            trustDomain: 'email',
+            reversible: false,
+            sideEffects: false,
+            params: {
+                messageId: { type: 'string', description: 'Message ID', required: true },
+            },
+        },
+        {
+            id: 'mail-send',
+            name: 'Send Email',
+            description: 'Send an email via Outlook',
+            trustMinimum: 3,
+            trustDomain: 'email',
+            reversible: false,
+            sideEffects: true,
+            params: {
+                to: { type: 'string', description: 'Recipient email', required: true },
+                subject: { type: 'string', description: 'Email subject', required: true },
+                body: { type: 'string', description: 'Email body', required: true },
+                cc: { type: 'string', description: 'CC recipients' },
+                bcc: { type: 'string', description: 'BCC recipients' },
+            },
+        },
+        {
+            id: 'mail-reply',
+            name: 'Reply to Email',
+            description: 'Reply to an email message',
+            trustMinimum: 3,
+            trustDomain: 'email',
+            reversible: false,
+            sideEffects: true,
+            params: {
+                messageId: { type: 'string', description: 'Message ID to reply to', required: true },
+                body: { type: 'string', description: 'Reply body', required: true },
+                replyAll: { type: 'boolean', description: 'Reply to all recipients' },
+            },
+        },
+        {
+            id: 'mail-forward',
+            name: 'Forward Email',
+            description: 'Forward an email message',
+            trustMinimum: 3,
+            trustDomain: 'email',
+            reversible: false,
+            sideEffects: true,
+            params: {
+                messageId: { type: 'string', description: 'Message ID to forward', required: true },
+                to: { type: 'string', description: 'Recipient email', required: true },
+                comment: { type: 'string', description: 'Comment to include' },
+            },
+        },
+        {
+            id: 'mail-move',
+            name: 'Move Email',
+            description: 'Move an email to a different folder',
+            trustMinimum: 2,
+            trustDomain: 'email',
+            reversible: true,
+            sideEffects: true,
+            params: {
+                messageId: { type: 'string', description: 'Message ID', required: true },
+                destinationFolderId: { type: 'string', description: 'Destination folder ID', required: true },
+            },
+        },
+        {
+            id: 'mail-archive',
+            name: 'Archive Email',
+            description: 'Archive an email message',
+            trustMinimum: 2,
+            trustDomain: 'email',
+            reversible: true,
+            sideEffects: true,
+            params: {
+                messageId: { type: 'string', description: 'Message ID', required: true },
+            },
+        },
+        {
+            id: 'mail-flag',
+            name: 'Flag Email',
+            description: 'Flag an email message for follow-up',
+            trustMinimum: 1,
+            trustDomain: 'email',
+            reversible: true,
+            sideEffects: true,
+            params: {
+                messageId: { type: 'string', description: 'Message ID', required: true },
+                flagStatus: { type: 'string', description: 'Flag status', default: 'flagged' },
+            },
+        },
+        {
+            id: 'mail-search',
+            name: 'Search Mail',
+            description: 'Search emails in Outlook',
+            trustMinimum: 1,
+            trustDomain: 'email',
+            reversible: false,
+            sideEffects: false,
+            params: {
+                query: { type: 'string', description: 'Search query', required: true },
+                maxResults: { type: 'number', description: 'Max results', default: 10 },
+            },
+        },
+        {
+            id: 'mail-draft',
+            name: 'Create Draft',
+            description: 'Create a draft email in Outlook',
+            trustMinimum: 2,
+            trustDomain: 'email',
+            reversible: true,
+            sideEffects: true,
+            params: {
+                to: { type: 'string', description: 'Recipient email', required: true },
+                subject: { type: 'string', description: 'Email subject', required: true },
+                body: { type: 'string', description: 'Email body', required: true },
+            },
+        },
+        // --- Calendar ---
+        {
+            id: 'calendar-list-events',
+            name: 'List Calendar Events',
+            description: 'List upcoming events from Outlook Calendar',
+            trustMinimum: 1,
+            trustDomain: 'calendar',
+            reversible: false,
+            sideEffects: false,
+            params: {
+                calendarId: { type: 'string', description: 'Calendar ID' },
+                maxResults: { type: 'number', description: 'Max events to return', default: 10 },
+                startDateTime: { type: 'string', description: 'Start time (ISO 8601)' },
+                endDateTime: { type: 'string', description: 'End time (ISO 8601)' },
+            },
+        },
+        {
+            id: 'calendar-create-event',
+            name: 'Create Calendar Event',
+            description: 'Create a new event in Outlook Calendar',
+            trustMinimum: 2,
+            trustDomain: 'calendar',
+            reversible: true,
+            sideEffects: true,
+            params: {
+                subject: { type: 'string', description: 'Event subject', required: true },
+                start: { type: 'string', description: 'Start time (ISO 8601)', required: true },
+                end: { type: 'string', description: 'End time (ISO 8601)', required: true },
+                body: { type: 'string', description: 'Event body' },
+                attendees: { type: 'array', description: 'List of attendee emails' },
+                location: { type: 'string', description: 'Event location' },
+                isOnlineMeeting: { type: 'boolean', description: 'Create as online meeting' },
+            },
+        },
+        {
+            id: 'calendar-update-event',
+            name: 'Update Calendar Event',
+            description: 'Update an existing calendar event',
+            trustMinimum: 2,
+            trustDomain: 'calendar',
+            reversible: true,
+            sideEffects: true,
+            params: {
+                eventId: { type: 'string', description: 'Event ID', required: true },
+                subject: { type: 'string', description: 'Updated subject' },
+                start: { type: 'string', description: 'Updated start time' },
+                end: { type: 'string', description: 'Updated end time' },
+            },
+        },
+        {
+            id: 'calendar-delete-event',
+            name: 'Delete Calendar Event',
+            description: 'Delete a calendar event',
+            trustMinimum: 3,
+            trustDomain: 'calendar',
+            reversible: false,
+            sideEffects: true,
+            params: {
+                eventId: { type: 'string', description: 'Event ID', required: true },
+            },
+        },
+        {
+            id: 'calendar-find-availability',
+            name: 'Find Availability',
+            description: 'Find free time slots for attendees',
+            trustMinimum: 1,
+            trustDomain: 'calendar',
+            reversible: false,
+            sideEffects: false,
+            params: {
+                attendees: { type: 'array', description: 'List of attendee emails', required: true },
+                startDateTime: { type: 'string', description: 'Start of window (ISO 8601)', required: true },
+                endDateTime: { type: 'string', description: 'End of window (ISO 8601)', required: true },
+                durationMinutes: { type: 'number', description: 'Desired slot duration in minutes', default: 30 },
+            },
+        },
+        // --- Contacts ---
+        {
+            id: 'contacts-list',
+            name: 'List Contacts',
+            description: 'List contacts from Outlook',
+            trustMinimum: 1,
+            trustDomain: 'integrations',
+            reversible: false,
+            sideEffects: false,
+            params: {
+                maxResults: { type: 'number', description: 'Max contacts to return', default: 20 },
+                search: { type: 'string', description: 'Search query' },
+            },
+        },
+        {
+            id: 'contacts-get',
+            name: 'Get Contact',
+            description: 'Get a specific contact',
+            trustMinimum: 1,
+            trustDomain: 'integrations',
+            reversible: false,
+            sideEffects: false,
+            params: {
+                contactId: { type: 'string', description: 'Contact ID', required: true },
+            },
+        },
+        // --- OneDrive ---
+        {
+            id: 'files-list',
+            name: 'List OneDrive Files',
+            description: 'List files in OneDrive',
+            trustMinimum: 1,
+            trustDomain: 'files',
+            reversible: false,
+            sideEffects: false,
+            params: {
+                folderId: { type: 'string', description: 'Folder ID (default: root)' },
+                maxResults: { type: 'number', description: 'Max files to return', default: 20 },
+            },
+        },
+        {
+            id: 'files-download',
+            name: 'Download File',
+            description: 'Download a file from OneDrive',
+            trustMinimum: 1,
+            trustDomain: 'files',
+            reversible: false,
+            sideEffects: false,
+            params: {
+                fileId: { type: 'string', description: 'File ID', required: true },
+            },
+        },
+        {
+            id: 'files-upload',
+            name: 'Upload File',
+            description: 'Upload a file to OneDrive',
+            trustMinimum: 2,
+            trustDomain: 'files',
+            reversible: true,
+            sideEffects: true,
+            params: {
+                name: { type: 'string', description: 'File name', required: true },
+                content: { type: 'string', description: 'File content', required: true },
+                folderId: { type: 'string', description: 'Parent folder ID' },
+            },
+        },
+        {
+            id: 'files-search',
+            name: 'Search Files',
+            description: 'Search files in OneDrive',
+            trustMinimum: 1,
+            trustDomain: 'files',
+            reversible: false,
+            sideEffects: false,
+            params: {
+                query: { type: 'string', description: 'Search query', required: true },
+                maxResults: { type: 'number', description: 'Max results', default: 10 },
+            },
+        },
+    ],
+    triggers: [
+        {
+            id: 'new-email',
+            name: 'New Email',
+            description: 'Triggered when a new email arrives',
+            type: 'poll',
+            pollIntervalMs: 60_000,
+        },
+        {
+            id: 'event-starting-soon',
+            name: 'Event Starting Soon',
+            description: 'Triggered when a calendar event is about to start',
+            type: 'poll',
+            pollIntervalMs: 60_000,
+        },
+        {
+            id: 'calendar-event-created',
+            name: 'Calendar Event Created',
+            description: 'Triggered when a new calendar event is created',
+            type: 'poll',
+            pollIntervalMs: 300_000,
+        },
+    ],
+    entities: [
+        {
+            id: 'email-message',
+            name: 'Email Message',
+            description: 'An Outlook email message',
+            fields: { id: 'string', from: 'string', to: 'string', subject: 'string', bodyPreview: 'string', receivedDateTime: 'string', importance: 'string', isRead: 'string' },
+        },
+        {
+            id: 'calendar-event',
+            name: 'Calendar Event',
+            description: 'An Outlook Calendar event',
+            fields: { id: 'string', subject: 'string', start: 'string', end: 'string', attendees: 'array', location: 'string', isOnlineMeeting: 'string' },
+        },
+        {
+            id: 'contact',
+            name: 'Contact',
+            description: 'An Outlook contact',
+            fields: { id: 'string', displayName: 'string', emailAddresses: 'array', companyName: 'string', jobTitle: 'string' },
+        },
+        {
+            id: 'drive-item',
+            name: 'Drive Item',
+            description: 'A OneDrive file or folder',
+            fields: { id: 'string', name: 'string', size: 'number', lastModifiedDateTime: 'string', webUrl: 'string' },
+        },
+    ],
+    async executeAction(actionId, params, token) {
+        switch (actionId) {
+            // --- Mail ---
+            case 'mail-list-messages': {
+                const folderId = params.folderId ?? 'inbox';
+                const top = params.maxResults ?? 10;
+                let path = `/me/mailFolders/${encodeURIComponent(folderId)}/messages?$top=${top}`;
+                if (params.query)
+                    path += `&$filter=${encodeURIComponent(params.query)}`;
+                const res = await graphFetch(token, path);
+                return { messages: res.value, folderId };
+            }
+            case 'mail-read-message': {
+                const msg = await graphFetch(token, `/me/messages/${encodeURIComponent(params.messageId)}`);
+                return msg;
+            }
+            case 'mail-send': {
+                const toRecipients = [{ emailAddress: { address: params.to } }];
+                const ccRecipients = params.cc
+                    ? params.cc.split(',').map(e => ({ emailAddress: { address: e.trim() } }))
+                    : undefined;
+                const bccRecipients = params.bcc
+                    ? params.bcc.split(',').map(e => ({ emailAddress: { address: e.trim() } }))
+                    : undefined;
+                await graphFetch(token, '/me/sendMail', {
+                    method: 'POST',
+                    body: {
+                        message: {
+                            toRecipients,
+                            subject: params.subject,
+                            body: { contentType: 'Text', content: params.body },
+                            ...(ccRecipients ? { ccRecipients } : {}),
+                            ...(bccRecipients ? { bccRecipients } : {}),
+                        },
+                    },
+                });
+                return { status: 'sent' };
+            }
+            case 'mail-reply': {
+                const action = params.replyAll ? 'replyAll' : 'reply';
+                await graphFetch(token, `/me/messages/${encodeURIComponent(params.messageId)}/${action}`, {
+                    method: 'POST',
+                    body: { comment: params.body },
+                });
+                return { messageId: params.messageId, status: 'replied' };
+            }
+            case 'mail-forward': {
+                await graphFetch(token, `/me/messages/${encodeURIComponent(params.messageId)}/forward`, {
+                    method: 'POST',
+                    body: {
+                        toRecipients: [{ emailAddress: { address: params.to } }],
+                        comment: params.comment ?? '',
+                    },
+                });
+                return { messageId: params.messageId, status: 'forwarded', to: params.to };
+            }
+            case 'mail-move': {
+                const moved = await graphFetch(token, `/me/messages/${encodeURIComponent(params.messageId)}/move`, {
+                    method: 'POST',
+                    body: { destinationId: params.destinationFolderId },
+                });
+                return { messageId: moved.id, status: 'moved', destinationFolderId: params.destinationFolderId };
+            }
+            case 'mail-archive': {
+                const archived = await graphFetch(token, `/me/messages/${encodeURIComponent(params.messageId)}/move`, {
+                    method: 'POST',
+                    body: { destinationId: 'archive' },
+                });
+                return { messageId: archived.id, status: 'archived' };
+            }
+            case 'mail-flag': {
+                const flagged = await graphFetch(token, `/me/messages/${encodeURIComponent(params.messageId)}`, {
+                    method: 'PATCH',
+                    body: { flag: { flagStatus: params.flagStatus ?? 'flagged' } },
+                });
+                return { messageId: flagged.id, status: 'flagged' };
+            }
+            case 'mail-search': {
+                const top = params.maxResults ?? 10;
+                const query = encodeURIComponent(`"${params.query}"`);
+                const res = await graphFetch(token, `/me/messages?$search=${query}&$top=${top}`);
+                return { messages: res.value, query: params.query };
+            }
+            case 'mail-draft': {
+                const draft = await graphFetch(token, '/me/messages', {
+                    method: 'POST',
+                    body: {
+                        toRecipients: [{ emailAddress: { address: params.to } }],
+                        subject: params.subject,
+                        body: { contentType: 'Text', content: params.body },
+                        isDraft: true,
+                    },
+                });
+                return { draftId: draft.id, status: 'created' };
+            }
+            // --- Calendar ---
+            case 'calendar-list-events': {
+                const top = params.maxResults ?? 10;
+                let res;
+                if (params.startDateTime && params.endDateTime) {
+                    const start = encodeURIComponent(params.startDateTime);
+                    const end = encodeURIComponent(params.endDateTime);
+                    res = await graphFetch(token, `/me/calendarView?startDateTime=${start}&endDateTime=${end}&$top=${top}`);
+                }
+                else {
+                    res = await graphFetch(token, `/me/events?$top=${top}&$orderby=start/dateTime`);
+                }
+                return { events: res.value };
+            }
+            case 'calendar-create-event': {
+                const attendees = params.attendees
+                    ? params.attendees.map(email => ({
+                        emailAddress: { address: email },
+                        type: 'required',
+                    }))
+                    : undefined;
+                const eventBody = {
+                    subject: params.subject,
+                    start: { dateTime: params.start, timeZone: 'UTC' },
+                    end: { dateTime: params.end, timeZone: 'UTC' },
+                };
+                if (params.body)
+                    eventBody.body = { contentType: 'Text', content: params.body };
+                if (attendees)
+                    eventBody.attendees = attendees;
+                if (params.location)
+                    eventBody.location = { displayName: params.location };
+                if (params.isOnlineMeeting)
+                    eventBody.isOnlineMeeting = true;
+                const created = await graphFetch(token, '/me/events', {
+                    method: 'POST',
+                    body: eventBody,
+                });
+                return { eventId: created.id, status: 'created', subject: created.subject };
+            }
+            case 'calendar-update-event': {
+                const updates = {};
+                if (params.subject)
+                    updates.subject = params.subject;
+                if (params.start)
+                    updates.start = { dateTime: params.start, timeZone: 'UTC' };
+                if (params.end)
+                    updates.end = { dateTime: params.end, timeZone: 'UTC' };
+                const updated = await graphFetch(token, `/me/events/${encodeURIComponent(params.eventId)}`, {
+                    method: 'PATCH',
+                    body: updates,
+                });
+                return { eventId: updated.id, status: 'updated' };
+            }
+            case 'calendar-delete-event': {
+                await graphFetch(token, `/me/events/${encodeURIComponent(params.eventId)}`, {
+                    method: 'DELETE',
+                });
+                return { eventId: params.eventId, status: 'deleted' };
+            }
+            case 'calendar-find-availability': {
+                const schedules = params.attendees;
+                const res = await graphFetch(token, '/me/calendar/getSchedule', {
+                    method: 'POST',
+                    body: {
+                        schedules,
+                        startTime: { dateTime: params.startDateTime, timeZone: 'UTC' },
+                        endTime: { dateTime: params.endDateTime, timeZone: 'UTC' },
+                        availabilityViewInterval: params.durationMinutes ?? 30,
+                    },
+                });
+                return res;
+            }
+            // --- Contacts ---
+            case 'contacts-list': {
+                const top = params.maxResults ?? 20;
+                let path = `/me/contacts?$top=${top}`;
+                if (params.search)
+                    path += `&$search="${encodeURIComponent(params.search)}"`;
+                const res = await graphFetch(token, path);
+                return { contacts: res.value };
+            }
+            case 'contacts-get': {
+                const contact = await graphFetch(token, `/me/contacts/${encodeURIComponent(params.contactId)}`);
+                return contact;
+            }
+            // --- OneDrive ---
+            case 'files-list': {
+                const top = params.maxResults ?? 20;
+                const path = params.folderId
+                    ? `/me/drive/items/${encodeURIComponent(params.folderId)}/children?$top=${top}`
+                    : `/me/drive/root/children?$top=${top}`;
+                const res = await graphFetch(token, path);
+                return { files: res.value };
+            }
+            case 'files-download': {
+                const downloadRes = await fetch(`${GRAPH_BASE}/me/drive/items/${encodeURIComponent(params.fileId)}/content`, {
+                    headers: { 'Authorization': `Bearer ${token}` },
+                    redirect: 'follow',
+                });
+                if (!downloadRes.ok) {
+                    throw new Error(`Graph API error: ${downloadRes.status} ${downloadRes.statusText}`);
+                }
+                const content = await downloadRes.text();
+                return { fileId: params.fileId, content };
+            }
+            case 'files-upload': {
+                const fileName = encodeURIComponent(params.name);
+                const uploadPath = params.folderId
+                    ? `/me/drive/items/${encodeURIComponent(params.folderId)}:/${fileName}:/content`
+                    : `/me/drive/root:/${fileName}:/content`;
+                const uploadRes = await fetch(`${GRAPH_BASE}${uploadPath}`, {
+                    method: 'PUT',
+                    headers: {
+                        'Authorization': `Bearer ${token}`,
+                        'Content-Type': 'application/octet-stream',
+                    },
+                    body: params.content,
+                });
+                if (!uploadRes.ok) {
+                    const err = await uploadRes.json().catch(() => ({}));
+                    throw new Error(`Graph API error: ${uploadRes.status} ${err.error?.message ?? uploadRes.statusText}`);
+                }
+                const uploaded = await uploadRes.json();
+                return { fileId: uploaded.id, status: 'uploaded', name: uploaded.name };
+            }
+            case 'files-search': {
+                const q = encodeURIComponent(params.query);
+                const top = params.maxResults ?? 10;
+                const res = await graphFetch(token, `/me/drive/root/search(q='${q}')?$top=${top}`);
+                return { files: res.value, query: params.query };
+            }
+            default:
+                throw new Error(`Unknown action: ${actionId}`);
+        }
+    },
+    async pollTrigger(triggerId, token, lastPollAt) {
+        switch (triggerId) {
+            case 'new-email': {
+                const res = await graphFetch(token, '/me/mailFolders/inbox/messages?$orderby=receivedDateTime desc&$top=10');
+                const since = lastPollAt ?? (Date.now() - 120_000);
+                const newMessages = res.value.filter(m => new Date(m.receivedDateTime).getTime() > since);
+                return newMessages.map(m => ({
+                    triggerId: 'new-email',
+                    connectorId: 'microsoft-365',
+                    timestamp: new Date(m.receivedDateTime).getTime(),
+                    data: { messageId: m.id, subject: m.subject, from: m.from },
+                }));
+            }
+            case 'event-starting-soon': {
+                const now = new Date();
+                const soon = new Date(now.getTime() + 15 * 60_000);
+                const start = encodeURIComponent(now.toISOString());
+                const end = encodeURIComponent(soon.toISOString());
+                const res = await graphFetch(token, `/me/calendarView?startDateTime=${start}&endDateTime=${end}&$top=10`);
+                return res.value.map(e => ({
+                    triggerId: 'event-starting-soon',
+                    connectorId: 'microsoft-365',
+                    timestamp: Date.now(),
+                    data: { eventId: e.id, subject: e.subject, start: e.start, end: e.end },
+                }));
+            }
+            case 'calendar-event-created': {
+                const res = await graphFetch(token, '/me/events?$orderby=createdDateTime desc&$top=10');
+                const since = lastPollAt ?? (Date.now() - 300_000);
+                const newEvents = res.value.filter(e => new Date(e.createdDateTime).getTime() > since);
+                return newEvents.map(e => ({
+                    triggerId: 'calendar-event-created',
+                    connectorId: 'microsoft-365',
+                    timestamp: new Date(e.createdDateTime).getTime(),
+                    data: { eventId: e.id, subject: e.subject, start: e.start },
+                }));
+            }
+            default:
+                return [];
+        }
+    },
+});
+//# sourceMappingURL=connector.js.map