@auxiora/channels 1.0.0

package/src/adapters/slack.ts

@@ -0,0 +1,252 @@
+import { App, LogLevel } from '@slack/bolt';
+import { audit } from '@auxiora/audit';
+import type {
+  ChannelAdapter,
+  InboundMessage,
+  OutboundMessage,
+  SendResult,
+} from '../types.js';
+
+export interface SlackAdapterConfig {
+  botToken: string;
+  appToken: string;
+  signingSecret?: string;
+  allowedChannels?: string[];
+  allowedUsers?: string[];
+}
+
+const MAX_MESSAGE_LENGTH = 40000;
+
+export class SlackAdapter implements ChannelAdapter {
+  readonly type = 'slack' as const;
+  readonly name = 'Slack';
+
+  private app: App;
+  private config: SlackAdapterConfig;
+  private messageHandler?: (message: InboundMessage) => Promise<void>;
+  private errorHandler?: (error: Error) => void;
+  private connected = false;
+  private botUserId?: string;
+
+  constructor(config: SlackAdapterConfig) {
+    this.config = config;
+    this.app = new App({
+      token: config.botToken,
+      appToken: config.appToken,
+      socketMode: true,
+      logLevel: LogLevel.WARN,
+    });
+
+    this.setupEventHandlers();
+  }
+
+  private setupEventHandlers(): void {
+    // Listen to all messages
+    this.app.message(async ({ message, say, client }) => {
+      // Type guard for regular messages
+      if (!('user' in message) || !('text' in message)) return;
+      if (message.subtype) return; // Ignore edited, deleted, etc.
+
+      // Get bot user ID if we don't have it
+      if (!this.botUserId) {
+        const auth = await client.auth.test();
+        this.botUserId = auth.user_id;
+      }
+
+      // Ignore bot's own messages
+      if (message.user === this.botUserId) return;
+
+      // Check allowed channels
+      if (this.config.allowedChannels?.length && message.channel && !this.config.allowedChannels.includes(message.channel as string)) {
+        audit('message.filtered', { channelType: 'slack', senderId: message.user as string, channelId: message.channel as string, reason: 'channel_not_allowed' });
+        return;
+      }
+
+      // Check allowed users
+      if (this.config.allowedUsers?.length && !this.config.allowedUsers.includes(message.user as string)) {
+        audit('message.filtered', { channelType: 'slack', senderId: message.user as string, channelId: message.channel as string, reason: 'user_not_allowed' });
+        return;
+      }
+
+      const inbound = this.toInboundMessage(message);
+
+      audit('message.received', {
+        channelType: 'slack',
+        senderId: inbound.senderId,
+        channelId: inbound.channelId,
+      });
+
+      if (this.messageHandler) {
+        try {
+          await this.messageHandler(inbound);
+        } catch (error) {
+          this.errorHandler?.(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    });
+
+    // Handle mentions specifically
+    this.app.event('app_mention', async ({ event, client }) => {
+      // Get bot user ID if we don't have it
+      if (!this.botUserId) {
+        const auth = await client.auth.test();
+        this.botUserId = auth.user_id;
+      }
+
+      // Check allowed channels
+      if (this.config.allowedChannels?.length && event.channel && !this.config.allowedChannels.includes(event.channel)) {
+        audit('message.filtered', { channelType: 'slack', senderId: event.user || '', channelId: event.channel, reason: 'channel_not_allowed' });
+        return;
+      }
+
+      // Check allowed users
+      if (this.config.allowedUsers?.length && event.user && !this.config.allowedUsers.includes(event.user)) {
+        audit('message.filtered', { channelType: 'slack', senderId: event.user, channelId: event.channel || '', reason: 'user_not_allowed' });
+        return;
+      }
+
+      // Strip bot mention from text
+      let content = event.text || '';
+      if (this.botUserId) {
+        content = content.replace(new RegExp(`<@${this.botUserId}>`, 'g'), '').trim();
+      }
+
+      const inbound: InboundMessage = {
+        id: event.ts,
+        channelType: 'slack',
+        channelId: event.channel || '',
+        senderId: event.user || '',
+        content,
+        timestamp: parseFloat(event.ts) * 1000,
+        replyToId: event.thread_ts,
+        raw: event,
+      };
+
+      audit('message.received', {
+        channelType: 'slack',
+        senderId: inbound.senderId,
+        channelId: inbound.channelId,
+        isMention: true,
+      });
+
+      if (this.messageHandler) {
+        try {
+          await this.messageHandler(inbound);
+        } catch (error) {
+          this.errorHandler?.(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    });
+
+    this.app.error(async (error) => {
+      audit('channel.error', { channelType: 'slack', error: error.message });
+      this.errorHandler?.(error);
+    });
+  }
+
+  private toInboundMessage(message: {
+    ts: string;
+    channel?: string;
+    user?: string;
+    text?: string;
+    thread_ts?: string;
+  }): InboundMessage {
+    return {
+      id: message.ts,
+      channelType: 'slack',
+      channelId: message.channel || '',
+      senderId: message.user || '',
+      content: message.text || '',
+      timestamp: parseFloat(message.ts) * 1000,
+      replyToId: message.thread_ts,
+      raw: message,
+    };
+  }
+
+  async connect(): Promise<void> {
+    await this.app.start();
+    this.connected = true;
+    audit('channel.connected', { channelType: 'slack' });
+  }
+
+  async disconnect(): Promise<void> {
+    await this.app.stop();
+    this.connected = false;
+    audit('channel.disconnected', { channelType: 'slack' });
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  async send(channelId: string, message: OutboundMessage): Promise<SendResult> {
+    try {
+      // Chunk long messages
+      const chunks = this.chunkMessage(message.content);
+      let lastTs: string | undefined;
+
+      for (const chunk of chunks) {
+        const result = await this.app.client.chat.postMessage({
+          channel: channelId,
+          text: chunk,
+          thread_ts: message.replyToId,
+          mrkdwn: message.formatting?.markdown !== false,
+        });
+        lastTs = result.ts;
+      }
+
+      audit('message.sent', {
+        channelType: 'slack',
+        channelId,
+        messageId: lastTs,
+      });
+
+      return { success: true, messageId: lastTs };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      audit('channel.error', {
+        channelType: 'slack',
+        action: 'send',
+        error: errorMessage,
+      });
+      return { success: false, error: errorMessage };
+    }
+  }
+
+  private chunkMessage(content: string): string[] {
+    if (content.length <= MAX_MESSAGE_LENGTH) {
+      return [content];
+    }
+
+    const chunks: string[] = [];
+    let remaining = content;
+
+    while (remaining.length > 0) {
+      if (remaining.length <= MAX_MESSAGE_LENGTH) {
+        chunks.push(remaining);
+        break;
+      }
+
+      let breakPoint = remaining.lastIndexOf('\n', MAX_MESSAGE_LENGTH);
+      if (breakPoint === -1 || breakPoint < MAX_MESSAGE_LENGTH / 2) {
+        breakPoint = remaining.lastIndexOf(' ', MAX_MESSAGE_LENGTH);
+      }
+      if (breakPoint === -1 || breakPoint < MAX_MESSAGE_LENGTH / 2) {
+        breakPoint = MAX_MESSAGE_LENGTH;
+      }
+
+      chunks.push(remaining.slice(0, breakPoint));
+      remaining = remaining.slice(breakPoint).trimStart();
+    }
+
+    return chunks;
+  }
+
+  onMessage(handler: (message: InboundMessage) => Promise<void>): void {
+    this.messageHandler = handler;
+  }
+
+  onError(handler: (error: Error) => void): void {
+    this.errorHandler = handler;
+  }
+}

package/src/adapters/teams.ts

@@ -0,0 +1,320 @@
+import { audit } from '@auxiora/audit';
+import type {
+  ChannelAdapter,
+  InboundMessage,
+  OutboundMessage,
+  SendResult,
+} from '../types.js';
+
+export interface TeamsAdapterConfig {
+  microsoftAppId: string;
+  microsoftAppPassword: string;
+  allowedTenants?: string[];
+  allowedUsers?: string[];
+}
+
+interface TeamsActivity {
+  type: string;
+  id: string;
+  timestamp: string;
+  channelId: string;
+  from: {
+    id: string;
+    name?: string;
+    aadObjectId?: string;
+  };
+  conversation: {
+    id: string;
+    conversationType?: string;
+    tenantId?: string;
+    isGroup?: boolean;
+  };
+  recipient?: {
+    id: string;
+    name?: string;
+  };
+  text?: string;
+  serviceUrl: string;
+  channelData?: Record<string, unknown>;
+  replyToId?: string;
+  attachments?: Array<{
+    contentType: string;
+    contentUrl?: string;
+    name?: string;
+    content?: unknown;
+  }>;
+}
+
+interface TeamsTokenResponse {
+  access_token: string;
+  expires_in: number;
+  token_type: string;
+}
+
+interface TeamsSendResponse {
+  id: string;
+}
+
+const MAX_MESSAGE_LENGTH = 28000;
+const TOKEN_URL = 'https://login.microsoftonline.com/botframework.com/oauth2/v2.0/token';
+
+export class TeamsAdapter implements ChannelAdapter {
+  readonly type = 'teams' as const;
+  readonly name = 'Microsoft Teams';
+
+  private config: TeamsAdapterConfig;
+  private messageHandler?: (message: InboundMessage) => Promise<void>;
+  private errorHandler?: (error: Error) => void;
+  private connected = false;
+  private accessToken?: string;
+  private tokenExpiry = 0;
+
+  constructor(config: TeamsAdapterConfig) {
+    this.config = config;
+  }
+
+  async connect(): Promise<void> {
+    // Verify credentials by obtaining a token
+    await this.getAccessToken();
+    this.connected = true;
+
+    audit('channel.connected', {
+      channelType: 'teams',
+      appId: this.config.microsoftAppId,
+    });
+  }
+
+  async disconnect(): Promise<void> {
+    this.connected = false;
+    this.accessToken = undefined;
+    this.tokenExpiry = 0;
+    audit('channel.disconnected', { channelType: 'teams' });
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  private async getAccessToken(): Promise<string> {
+    if (this.accessToken && Date.now() < this.tokenExpiry) {
+      return this.accessToken;
+    }
+
+    const params = new URLSearchParams({
+      grant_type: 'client_credentials',
+      client_id: this.config.microsoftAppId,
+      client_secret: this.config.microsoftAppPassword,
+      scope: 'https://api.botframework.com/.default',
+    });
+
+    const response = await fetch(TOKEN_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: params.toString(),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to obtain Teams token: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json() as TeamsTokenResponse;
+    this.accessToken = data.access_token;
+    // Expire 5 minutes early to avoid edge cases
+    this.tokenExpiry = Date.now() + (data.expires_in - 300) * 1000;
+
+    return this.accessToken;
+  }
+
+  /**
+   * Handle incoming webhook from Microsoft Bot Framework.
+   * Call this from your HTTP server when receiving POST to /api/messages.
+   */
+  async handleWebhook(activity: TeamsActivity): Promise<void> {
+    if (activity.type !== 'message') return;
+    if (!activity.text) return;
+
+    // Check allowed tenants
+    const tenantId = activity.conversation.tenantId;
+    if (tenantId && this.config.allowedTenants?.length && !this.config.allowedTenants.includes(tenantId)) {
+      audit('message.filtered', { channelType: 'teams', senderId: activity.from.id, tenantId, reason: 'tenant_not_allowed' });
+      return;
+    }
+
+    // Check allowed users
+    if (this.config.allowedUsers?.length && !this.config.allowedUsers.includes(activity.from.id)) {
+      audit('message.filtered', { channelType: 'teams', senderId: activity.from.id, reason: 'user_not_allowed' });
+      return;
+    }
+
+    const inbound = this.toInboundMessage(activity);
+
+    audit('message.received', {
+      channelType: 'teams',
+      senderId: inbound.senderId,
+      channelId: inbound.channelId,
+    });
+
+    if (this.messageHandler) {
+      try {
+        await this.messageHandler(inbound);
+      } catch (error) {
+        this.errorHandler?.(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  }
+
+  private toInboundMessage(activity: TeamsActivity): InboundMessage {
+    // Strip bot mention from content
+    let content = activity.text || '';
+    if (activity.recipient?.name) {
+      content = content.replace(
+        new RegExp(`<at>${activity.recipient.name}</at>`, 'gi'),
+        '',
+      ).trim();
+    }
+
+    return {
+      id: activity.id,
+      channelType: 'teams',
+      channelId: activity.conversation.id,
+      senderId: activity.from.id,
+      senderName: activity.from.name,
+      content,
+      timestamp: new Date(activity.timestamp).getTime(),
+      replyToId: activity.replyToId,
+      attachments: activity.attachments?.map((a) => ({
+        type: a.contentType.startsWith('image/')
+          ? 'image' as const
+          : 'file' as const,
+        url: a.contentUrl,
+        mimeType: a.contentType,
+        filename: a.name,
+      })),
+      raw: activity,
+    };
+  }
+
+  async send(channelId: string, message: OutboundMessage): Promise<SendResult> {
+    try {
+      const token = await this.getAccessToken();
+      const chunks = this.chunkMessage(message.content);
+      let lastMessageId: string | undefined;
+
+      // We need the serviceUrl from the incoming activity
+      // For now, use the default Bot Framework service URL
+      const serviceUrl = 'https://smba.trafficmanager.net/teams/';
+
+      for (const chunk of chunks) {
+        const activity = {
+          type: 'message',
+          text: chunk,
+          ...(message.replyToId ? { replyToId: message.replyToId } : {}),
+        };
+
+        const url = `${serviceUrl}v3/conversations/${encodeURIComponent(channelId)}/activities`;
+        const response = await fetch(url, {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify(activity),
+        });
+
+        if (!response.ok) {
+          const errorText = await response.text().catch(() => response.statusText);
+          throw new Error(`Teams API error ${response.status}: ${errorText}`);
+        }
+
+        const result = await response.json() as TeamsSendResponse;
+        lastMessageId = result.id;
+      }
+
+      audit('message.sent', {
+        channelType: 'teams',
+        channelId,
+        messageId: lastMessageId,
+      });
+
+      return { success: true, messageId: lastMessageId };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      audit('channel.error', {
+        channelType: 'teams',
+        action: 'send',
+        error: errorMessage,
+      });
+      return { success: false, error: errorMessage };
+    }
+  }
+
+  private chunkMessage(content: string): string[] {
+    if (content.length <= MAX_MESSAGE_LENGTH) {
+      return [content];
+    }
+
+    const chunks: string[] = [];
+    let remaining = content;
+
+    while (remaining.length > 0) {
+      if (remaining.length <= MAX_MESSAGE_LENGTH) {
+        chunks.push(remaining);
+        break;
+      }
+
+      let breakPoint = remaining.lastIndexOf('\n', MAX_MESSAGE_LENGTH);
+      if (breakPoint === -1 || breakPoint < MAX_MESSAGE_LENGTH / 2) {
+        breakPoint = remaining.lastIndexOf(' ', MAX_MESSAGE_LENGTH);
+      }
+      if (breakPoint === -1 || breakPoint < MAX_MESSAGE_LENGTH / 2) {
+        breakPoint = MAX_MESSAGE_LENGTH;
+      }
+
+      chunks.push(remaining.slice(0, breakPoint));
+      remaining = remaining.slice(breakPoint).trimStart();
+    }
+
+    return chunks;
+  }
+
+  async startTyping(channelId: string): Promise<() => void> {
+    let token: string;
+    try {
+      token = await this.getAccessToken();
+    } catch {
+      return () => {};
+    }
+    const serviceUrl = 'https://smba.trafficmanager.net/teams/';
+    const url = `${serviceUrl}v3/conversations/${encodeURIComponent(channelId)}/activities`;
+
+    // Send typing activity immediately, repeat every 3s
+    let stopped = false;
+    const sendTyping = () =>
+      fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ type: 'typing' }),
+      }).catch(() => {});
+
+    sendTyping();
+    const interval = setInterval(() => {
+      if (stopped) return;
+      sendTyping();
+    }, 3000);
+    return () => {
+      stopped = true;
+      clearInterval(interval);
+    };
+  }
+
+  onMessage(handler: (message: InboundMessage) => Promise<void>): void {
+    this.messageHandler = handler;
+  }
+
+  onError(handler: (error: Error) => void): void {
+    this.errorHandler = handler;
+  }
+}