digital-tools 2.0.2 → 2.1.1

package/src/providers/messaging/slack.js

@@ -0,0 +1,393 @@
+/**
+ * Slack Messaging Provider
+ *
+ * Concrete implementation of MessagingProvider using Slack API.
+ *
+ * @packageDocumentation
+ */
+import { defineProvider } from '../registry.js';
+const SLACK_API_URL = 'https://slack.com/api';
+/**
+ * Slack provider info
+ */
+export const slackInfo = {
+    id: 'messaging.slack',
+    name: 'Slack',
+    description: 'Slack team messaging platform',
+    category: 'messaging',
+    website: 'https://slack.com',
+    docsUrl: 'https://api.slack.com/docs',
+    requiredConfig: ['accessToken'],
+    optionalConfig: ['botToken', 'signingSecret'],
+};
+/**
+ * Create Slack messaging provider
+ */
+export function createSlackProvider(config) {
+    let token;
+    async function slackApi(method, body) {
+        const response = await fetch(`${SLACK_API_URL}/${method}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json; charset=utf-8',
+                Authorization: `Bearer ${token}`,
+            },
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        const data = await response.json();
+        return data;
+    }
+    return {
+        info: slackInfo,
+        async initialize(cfg) {
+            token = (cfg.accessToken || cfg.botToken);
+            if (!token) {
+                throw new Error('Slack access token or bot token is required');
+            }
+        },
+        async healthCheck() {
+            const start = Date.now();
+            try {
+                const data = await slackApi('auth.test');
+                return {
+                    healthy: data.ok === true,
+                    latencyMs: Date.now() - start,
+                    message: data.ok ? `Connected as ${data.user}` : data.error,
+                    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() {
+            // No cleanup needed
+        },
+        async send(options) {
+            const body = {
+                text: options.text,
+            };
+            if (options.channel) {
+                body.channel = options.channel;
+            }
+            else if (options.userId) {
+                // Open DM conversation first
+                const dm = await slackApi('conversations.open', { users: options.userId });
+                if (!dm.ok) {
+                    return {
+                        success: false,
+                        error: { code: dm.error, message: `Failed to open DM: ${dm.error}` },
+                    };
+                }
+                body.channel = dm.channel.id;
+            }
+            else {
+                return {
+                    success: false,
+                    error: { code: 'MISSING_TARGET', message: 'Either channel or userId is required' },
+                };
+            }
+            if (options.threadId) {
+                body.thread_ts = options.threadId;
+            }
+            if (options.blocks) {
+                body.blocks = options.blocks;
+            }
+            if (options.metadata) {
+                body.metadata = {
+                    event_type: 'message_metadata',
+                    event_payload: options.metadata,
+                };
+            }
+            const data = await slackApi('chat.postMessage', body);
+            if (data.ok) {
+                return {
+                    success: true,
+                    messageId: data.ts,
+                    timestamp: data.ts,
+                    channel: data.channel,
+                };
+            }
+            return {
+                success: false,
+                error: { code: data.error, message: data.error },
+            };
+        },
+        async edit(messageId, text, blocks) {
+            const body = {
+                ts: messageId,
+                text,
+            };
+            if (blocks) {
+                body.blocks = blocks;
+            }
+            const data = await slackApi('chat.update', body);
+            if (data.ok) {
+                return {
+                    success: true,
+                    messageId: data.ts,
+                    timestamp: data.ts,
+                    channel: data.channel,
+                };
+            }
+            return {
+                success: false,
+                error: { code: data.error, message: data.error },
+            };
+        },
+        async delete(messageId, channel) {
+            const data = await slackApi('chat.delete', { ts: messageId, channel });
+            return data.ok === true;
+        },
+        async react(messageId, channel, emoji) {
+            const data = await slackApi('reactions.add', {
+                name: emoji.replace(/:/g, ''),
+                timestamp: messageId,
+                channel,
+            });
+            return data.ok === true;
+        },
+        async unreact(messageId, channel, emoji) {
+            const data = await slackApi('reactions.remove', {
+                name: emoji.replace(/:/g, ''),
+                timestamp: messageId,
+                channel,
+            });
+            return data.ok === true;
+        },
+        async getMessage(messageId, channel) {
+            const data = await slackApi('conversations.history', {
+                channel,
+                latest: messageId,
+                inclusive: true,
+                limit: 1,
+            });
+            if (!data.ok || !data.messages?.length) {
+                return null;
+            }
+            const msg = data.messages[0];
+            return mapSlackMessage(msg, channel);
+        },
+        async listMessages(channel, options) {
+            const body = {
+                channel,
+                limit: options?.limit || 100,
+            };
+            if (options?.cursor) {
+                body.cursor = options.cursor;
+            }
+            if (options?.since) {
+                body.oldest = (options.since.getTime() / 1000).toString();
+            }
+            if (options?.until) {
+                body.latest = (options.until.getTime() / 1000).toString();
+            }
+            const data = await slackApi('conversations.history', body);
+            if (!data.ok) {
+                return { items: [], hasMore: false };
+            }
+            return {
+                items: data.messages.map((msg) => mapSlackMessage(msg, channel)),
+                hasMore: data.has_more || false,
+                nextCursor: data.response_metadata?.next_cursor,
+            };
+        },
+        async searchMessages(query, options) {
+            const data = await slackApi('search.messages', {
+                query,
+                count: options?.limit || 100,
+                page: options?.offset ? Math.floor(options.offset / (options.limit || 100)) + 1 : 1,
+            });
+            if (!data.ok) {
+                return { items: [], hasMore: false };
+            }
+            return {
+                items: data.messages.matches.map((match) => mapSlackMessage(match, match.channel.id)),
+                hasMore: data.messages.paging.pages > data.messages.paging.page,
+                total: data.messages.total,
+            };
+        },
+        async listChannels(options) {
+            const body = {
+                limit: options?.limit || 100,
+                exclude_archived: options?.excludeArchived !== false,
+            };
+            if (options?.cursor) {
+                body.cursor = options.cursor;
+            }
+            if (options?.types) {
+                body.types = options.types.map((t) => (t === 'private' ? 'private_channel' : 'public_channel')).join(',');
+            }
+            const data = await slackApi('conversations.list', body);
+            if (!data.ok) {
+                return { items: [], hasMore: false };
+            }
+            return {
+                items: data.channels.map(mapSlackChannel),
+                hasMore: data.response_metadata?.next_cursor ? true : false,
+                nextCursor: data.response_metadata?.next_cursor,
+            };
+        },
+        async getChannel(channelId) {
+            const data = await slackApi('conversations.info', { channel: channelId });
+            if (!data.ok) {
+                return null;
+            }
+            return mapSlackChannel(data.channel);
+        },
+        async createChannel(name, options) {
+            const body = {
+                name,
+                is_private: options?.isPrivate || false,
+            };
+            const data = await slackApi('conversations.create', body);
+            if (!data.ok) {
+                throw new Error(`Failed to create channel: ${data.error}`);
+            }
+            const channel = mapSlackChannel(data.channel);
+            // Set topic if provided
+            if (options?.topic) {
+                await slackApi('conversations.setTopic', {
+                    channel: data.channel.id,
+                    topic: options.topic,
+                });
+            }
+            // Set description/purpose if provided
+            if (options?.description) {
+                await slackApi('conversations.setPurpose', {
+                    channel: data.channel.id,
+                    purpose: options.description,
+                });
+            }
+            return channel;
+        },
+        async archiveChannel(channelId) {
+            const data = await slackApi('conversations.archive', { channel: channelId });
+            return data.ok === true;
+        },
+        async joinChannel(channelId) {
+            const data = await slackApi('conversations.join', { channel: channelId });
+            return data.ok === true;
+        },
+        async leaveChannel(channelId) {
+            const data = await slackApi('conversations.leave', { channel: channelId });
+            return data.ok === true;
+        },
+        async listMembers(options) {
+            const body = {
+                limit: options?.limit || 100,
+            };
+            if (options?.cursor) {
+                body.cursor = options.cursor;
+            }
+            let data;
+            if (options?.channel) {
+                // Get members of specific channel
+                data = await slackApi('conversations.members', { ...body, channel: options.channel });
+                if (!data.ok) {
+                    return { items: [], hasMore: false };
+                }
+                // Fetch user info for each member
+                const members = await Promise.all(data.members.map(async (userId) => {
+                    const userInfo = await slackApi('users.info', { user: userId });
+                    return userInfo.ok ? mapSlackUser(userInfo.user) : null;
+                }));
+                return {
+                    items: members.filter(Boolean),
+                    hasMore: data.response_metadata?.next_cursor ? true : false,
+                    nextCursor: data.response_metadata?.next_cursor,
+                };
+            }
+            else {
+                // Get all workspace members
+                data = await slackApi('users.list', body);
+                if (!data.ok) {
+                    return { items: [], hasMore: false };
+                }
+                return {
+                    items: data.members.filter((m) => !m.deleted).map(mapSlackUser),
+                    hasMore: data.response_metadata?.next_cursor ? true : false,
+                    nextCursor: data.response_metadata?.next_cursor,
+                };
+            }
+        },
+        async getMember(userId) {
+            const data = await slackApi('users.info', { user: userId });
+            if (!data.ok) {
+                return null;
+            }
+            return mapSlackUser(data.user);
+        },
+        async getPresence(userId) {
+            const data = await slackApi('users.getPresence', { user: userId });
+            return {
+                userId,
+                presence: data.presence === 'active' ? 'online' : 'away',
+            };
+        },
+        async getWorkspace() {
+            const data = await slackApi('team.info');
+            if (!data.ok) {
+                throw new Error(`Failed to get workspace info: ${data.error}`);
+            }
+            return {
+                id: data.team.id,
+                name: data.team.name,
+                domain: data.team.domain,
+                icon: data.team.icon?.image_132,
+            };
+        },
+    };
+}
+function mapSlackMessage(msg, channel) {
+    return {
+        id: msg.ts,
+        channel,
+        userId: msg.user,
+        text: msg.text,
+        timestamp: msg.ts,
+        threadId: msg.thread_ts,
+        replyCount: msg.reply_count,
+        reactions: msg.reactions?.map((r) => ({
+            emoji: r.name,
+            count: r.count,
+            users: r.users,
+        })),
+        edited: !!msg.edited,
+        editedAt: msg.edited?.ts ? new Date(parseFloat(msg.edited.ts) * 1000) : undefined,
+    };
+}
+function mapSlackChannel(ch) {
+    return {
+        id: ch.id,
+        name: ch.name,
+        topic: ch.topic?.value,
+        description: ch.purpose?.value,
+        isPrivate: ch.is_private || false,
+        isArchived: ch.is_archived || false,
+        memberCount: ch.num_members || 0,
+        createdAt: new Date(ch.created * 1000),
+    };
+}
+function mapSlackUser(user) {
+    return {
+        id: user.id,
+        username: user.name,
+        displayName: user.real_name || user.profile?.display_name || user.name,
+        email: user.profile?.email,
+        avatar: user.profile?.image_192,
+        title: user.profile?.title,
+        isAdmin: user.is_admin || user.is_owner || false,
+        isBot: user.is_bot || false,
+        timezone: user.tz,
+    };
+}
+/**
+ * Slack provider definition
+ */
+export const slackProvider = defineProvider(slackInfo, async (config) => createSlackProvider(config));

package/src/providers/messaging/twilio-sms.js

@@ -0,0 +1,249 @@
+/**
+ * Twilio SMS Provider
+ *
+ * Concrete implementation of SmsProvider using Twilio API.
+ *
+ * @packageDocumentation
+ */
+import { defineProvider } from '../registry.js';
+const TWILIO_API_URL = 'https://api.twilio.com/2010-04-01';
+/**
+ * Twilio SMS provider info
+ */
+export const twilioSmsInfo = {
+    id: 'messaging.twilio-sms',
+    name: 'Twilio SMS',
+    description: 'Twilio SMS messaging service',
+    category: 'messaging',
+    website: 'https://twilio.com',
+    docsUrl: 'https://www.twilio.com/docs/sms',
+    requiredConfig: ['accountSid', 'authToken'],
+    optionalConfig: ['defaultFrom', 'messagingServiceSid'],
+};
+/**
+ * Create Twilio SMS provider
+ */
+export function createTwilioSmsProvider(config) {
+    let accountSid;
+    let authToken;
+    let defaultFrom;
+    let messagingServiceSid;
+    function getAuthHeader() {
+        return `Basic ${Buffer.from(`${accountSid}:${authToken}`).toString('base64')}`;
+    }
+    async function twilioApi(path, method = 'GET', body) {
+        const url = `${TWILIO_API_URL}/Accounts/${accountSid}${path}`;
+        const response = await fetch(url, {
+            method,
+            headers: {
+                Authorization: getAuthHeader(),
+                ...(body && { 'Content-Type': 'application/x-www-form-urlencoded' }),
+            },
+            body: body?.toString(),
+        });
+        return response.json();
+    }
+    return {
+        info: twilioSmsInfo,
+        async initialize(cfg) {
+            accountSid = cfg.accountSid;
+            authToken = cfg.authToken;
+            defaultFrom = cfg.defaultFrom;
+            messagingServiceSid = cfg.messagingServiceSid;
+            if (!accountSid || !authToken) {
+                throw new Error('Twilio account SID and auth token are required');
+            }
+        },
+        async healthCheck() {
+            const start = Date.now();
+            try {
+                const data = await twilioApi('.json');
+                return {
+                    healthy: data.status === 'active',
+                    latencyMs: Date.now() - start,
+                    message: data.status === 'active' ? 'Connected' : `Status: ${data.status}`,
+                    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() {
+            // No cleanup needed
+        },
+        async send(options) {
+            const from = options.from || defaultFrom;
+            if (!from && !messagingServiceSid) {
+                return {
+                    success: false,
+                    error: { code: 'MISSING_FROM', message: 'From number or messaging service SID is required' },
+                };
+            }
+            const body = new URLSearchParams();
+            body.append('To', options.to);
+            body.append('Body', options.body);
+            if (messagingServiceSid) {
+                body.append('MessagingServiceSid', messagingServiceSid);
+            }
+            else if (from) {
+                body.append('From', from);
+            }
+            if (options.statusCallback) {
+                body.append('StatusCallback', options.statusCallback);
+            }
+            try {
+                const data = await twilioApi('/Messages.json', 'POST', body);
+                if (data.sid) {
+                    return {
+                        success: true,
+                        messageId: data.sid,
+                        status: data.status,
+                    };
+                }
+                return {
+                    success: false,
+                    error: {
+                        code: data.code?.toString() || 'UNKNOWN',
+                        message: data.message || 'Failed to send SMS',
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'NETWORK_ERROR',
+                        message: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                };
+            }
+        },
+        async sendMms(options) {
+            const from = options.from || defaultFrom;
+            if (!from && !messagingServiceSid) {
+                return {
+                    success: false,
+                    error: { code: 'MISSING_FROM', message: 'From number or messaging service SID is required' },
+                };
+            }
+            const body = new URLSearchParams();
+            body.append('To', options.to);
+            body.append('Body', options.body);
+            if (messagingServiceSid) {
+                body.append('MessagingServiceSid', messagingServiceSid);
+            }
+            else if (from) {
+                body.append('From', from);
+            }
+            // Add media URLs
+            options.mediaUrls.forEach((url) => {
+                body.append('MediaUrl', url);
+            });
+            if (options.statusCallback) {
+                body.append('StatusCallback', options.statusCallback);
+            }
+            try {
+                const data = await twilioApi('/Messages.json', 'POST', body);
+                if (data.sid) {
+                    return {
+                        success: true,
+                        messageId: data.sid,
+                        status: data.status,
+                    };
+                }
+                return {
+                    success: false,
+                    error: {
+                        code: data.code?.toString() || 'UNKNOWN',
+                        message: data.message || 'Failed to send MMS',
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'NETWORK_ERROR',
+                        message: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                };
+            }
+        },
+        async getStatus(messageId) {
+            const data = await twilioApi(`/Messages/${messageId}.json`);
+            return {
+                messageId: data.sid,
+                status: mapTwilioStatus(data.status),
+                errorCode: data.error_code?.toString(),
+                errorMessage: data.error_message,
+            };
+        },
+        async list(options) {
+            const params = new URLSearchParams();
+            if (options?.limit) {
+                params.append('PageSize', options.limit.toString());
+            }
+            if (options?.to) {
+                params.append('To', options.to);
+            }
+            if (options?.from) {
+                params.append('From', options.from);
+            }
+            if (options?.since) {
+                params.append('DateSent>', options.since.toISOString().split('T')[0]);
+            }
+            if (options?.until) {
+                params.append('DateSent<', options.until.toISOString().split('T')[0]);
+            }
+            const queryString = params.toString();
+            const path = `/Messages.json${queryString ? `?${queryString}` : ''}`;
+            const data = await twilioApi(path);
+            return {
+                items: data.messages?.map(mapTwilioMessage) || [],
+                hasMore: !!data.next_page_uri,
+                nextCursor: data.next_page_uri,
+            };
+        },
+    };
+}
+function mapTwilioStatus(status) {
+    switch (status) {
+        case 'queued':
+        case 'accepted':
+            return 'queued';
+        case 'sending':
+            return 'sending';
+        case 'sent':
+            return 'sent';
+        case 'delivered':
+            return 'delivered';
+        case 'failed':
+            return 'failed';
+        case 'undelivered':
+            return 'undelivered';
+        default:
+            return 'queued';
+    }
+}
+function mapTwilioMessage(msg) {
+    return {
+        id: msg.sid,
+        to: msg.to,
+        from: msg.from,
+        body: msg.body,
+        status: msg.status,
+        direction: msg.direction === 'inbound' ? 'inbound' : 'outbound',
+        sentAt: msg.date_sent ? new Date(msg.date_sent) : undefined,
+        deliveredAt: msg.status === 'delivered' ? new Date(msg.date_updated) : undefined,
+    };
+}
+/**
+ * Twilio SMS provider definition
+ */
+export const twilioSmsProvider = defineProvider(twilioSmsInfo, async (config) => createTwilioSmsProvider(config));

package/src/providers/project-management/index.js

@@ -0,0 +1,17 @@
+/**
+ * Project Management Providers
+ *
+ * @packageDocumentation
+ */
+export { linearInfo, linearProvider, createLinearProvider } from './linear.js';
+import { linearProvider } from './linear.js';
+/**
+ * Register all project management providers
+ */
+export function registerProjectManagementProviders() {
+    linearProvider.register();
+}
+/**
+ * All project management providers
+ */
+export const projectManagementProviders = [linearProvider];