@auxiora/channels 1.0.0

package/src/adapters/bluebubbles.ts

@@ -0,0 +1,294 @@
+import { audit } from '@auxiora/audit';
+import type {
+  ChannelAdapter,
+  InboundMessage,
+  OutboundMessage,
+  SendResult,
+} from '../types.js';
+
+export interface BlueBubblesAdapterConfig {
+  serverUrl: string;
+  password: string;
+  allowedAddresses?: string[];
+}
+
+interface BlueBubblesMessage {
+  guid: string;
+  text: string;
+  handle?: {
+    address: string;
+    service: string;
+    uncanonicalizedId?: string;
+  };
+  chats?: Array<{
+    guid: string;
+    chatIdentifier: string;
+    displayName?: string;
+    participants?: Array<{
+      address: string;
+    }>;
+  }>;
+  dateCreated: number;
+  isFromMe: boolean;
+  threadOriginatorGuid?: string;
+  attachments?: Array<{
+    guid: string;
+    mimeType: string;
+    transferName: string;
+    totalBytes: number;
+  }>;
+}
+
+interface BlueBubblesWebhookEvent {
+  type: string;
+  data: BlueBubblesMessage;
+}
+
+interface BlueBubblesSendResponse {
+  status: number;
+  message: string;
+  data?: BlueBubblesMessage;
+}
+
+const MAX_MESSAGE_LENGTH = 20000;
+
+export class BlueBubblesAdapter implements ChannelAdapter {
+  readonly type = 'bluebubbles' as const;
+  readonly name = 'BlueBubbles (iMessage)';
+
+  private config: BlueBubblesAdapterConfig;
+  private messageHandler?: (message: InboundMessage) => Promise<void>;
+  private errorHandler?: (error: Error) => void;
+  private connected = false;
+
+  constructor(config: BlueBubblesAdapterConfig) {
+    this.config = config;
+  }
+
+  private get baseUrl(): string {
+    return this.config.serverUrl.replace(/\/+$/, '');
+  }
+
+  private async apiRequest<T>(
+    method: string,
+    path: string,
+    body?: Record<string, unknown>,
+  ): Promise<T> {
+    const url = new URL(path, this.baseUrl);
+    url.searchParams.set('password', this.config.password);
+
+    const response = await fetch(url.toString(), {
+      method,
+      headers: body ? { 'Content-Type': 'application/json' } : undefined,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `BlueBubbles API error ${response.status}: ${response.statusText}`,
+      );
+    }
+
+    return (await response.json()) as T;
+  }
+
+  async connect(): Promise<void> {
+    // Verify connection by fetching server info
+    await this.apiRequest<{ status: number; message: string }>('GET', '/api/v1/server/info');
+    this.connected = true;
+
+    audit('channel.connected', {
+      channelType: 'bluebubbles',
+      serverUrl: this.baseUrl,
+    });
+  }
+
+  async disconnect(): Promise<void> {
+    this.connected = false;
+    audit('channel.disconnected', { channelType: 'bluebubbles' });
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  /**
+   * Handle incoming webhook from BlueBubbles server.
+   * Configure your BlueBubbles server to send webhooks to your endpoint.
+   */
+  async handleWebhook(event: BlueBubblesWebhookEvent): Promise<void> {
+    if (event.type !== 'new-message') return;
+
+    const msg = event.data;
+
+    // Ignore own messages
+    if (msg.isFromMe) return;
+
+    // Must have text content
+    if (!msg.text) return;
+
+    // Check allowed addresses
+    const senderAddress = msg.handle?.address;
+    if (
+      senderAddress &&
+      this.config.allowedAddresses?.length &&
+      !this.config.allowedAddresses.includes(senderAddress)
+    ) {
+      audit('message.filtered', {
+        channelType: 'bluebubbles',
+        senderId: senderAddress,
+        reason: 'address_not_allowed',
+      });
+      return;
+    }
+
+    const inbound = this.toInboundMessage(msg);
+
+    audit('message.received', {
+      channelType: 'bluebubbles',
+      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(msg: BlueBubblesMessage): InboundMessage {
+    const chatGuid = msg.chats?.[0]?.guid || msg.handle?.address || 'unknown';
+
+    return {
+      id: msg.guid,
+      channelType: 'bluebubbles',
+      channelId: chatGuid,
+      senderId: msg.handle?.address || 'unknown',
+      senderName: msg.handle?.uncanonicalizedId || msg.handle?.address,
+      content: msg.text,
+      timestamp: msg.dateCreated,
+      replyToId: msg.threadOriginatorGuid,
+      attachments: msg.attachments?.map((a) => ({
+        type: a.mimeType.startsWith('image/')
+          ? ('image' as const)
+          : a.mimeType.startsWith('audio/')
+            ? ('audio' as const)
+            : a.mimeType.startsWith('video/')
+              ? ('video' as const)
+              : ('file' as const),
+        mimeType: a.mimeType,
+        filename: a.transferName,
+        size: a.totalBytes,
+      })),
+      raw: msg,
+    };
+  }
+
+  async send(channelId: string, message: OutboundMessage): Promise<SendResult> {
+    try {
+      const chunks = this.chunkMessage(message.content);
+      let lastGuid: string | undefined;
+
+      for (const chunk of chunks) {
+        const body: Record<string, unknown> = {
+          chatGuid: channelId,
+          message: chunk,
+          method: 'private-api',
+        };
+
+        if (message.replyToId) {
+          body.selectedMessageGuid = message.replyToId;
+        }
+
+        const result = await this.apiRequest<BlueBubblesSendResponse>(
+          'POST',
+          '/api/v1/message/text',
+          body,
+        );
+
+        if (result.status !== 200) {
+          throw new Error(`BlueBubbles send error: ${result.message}`);
+        }
+
+        lastGuid = result.data?.guid;
+      }
+
+      audit('message.sent', {
+        channelType: 'bluebubbles',
+        channelId,
+        messageId: lastGuid,
+      });
+
+      return { success: true, messageId: lastGuid };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      audit('channel.error', {
+        channelType: 'bluebubbles',
+        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> {
+    // BlueBubbles supports typing indicators via the private API
+    this.apiRequest('POST', '/api/v1/chat/typing', {
+      chatGuid: channelId,
+      status: 'typing',
+    }).catch((e: Error) => {
+      audit('channel.error', {
+        channelType: 'bluebubbles',
+        action: 'typing',
+        error: e.message,
+      });
+    });
+
+    return () => {
+      this.apiRequest('POST', '/api/v1/chat/typing', {
+        chatGuid: channelId,
+        status: 'idle',
+      }).catch(() => {});
+    };
+  }
+
+  onMessage(handler: (message: InboundMessage) => Promise<void>): void {
+    this.messageHandler = handler;
+  }
+
+  onError(handler: (error: Error) => void): void {
+    this.errorHandler = handler;
+  }
+}

package/src/adapters/discord.ts

@@ -0,0 +1,253 @@
+import {
+  Client,
+  GatewayIntentBits,
+  Partials,
+  Message as DiscordMessage,
+  ChannelType as DiscordChannelType,
+} from 'discord.js';
+import { audit } from '@auxiora/audit';
+import type {
+  ChannelAdapter,
+  InboundMessage,
+  OutboundMessage,
+  SendResult,
+} from '../types.js';
+
+export interface DiscordAdapterConfig {
+  token: string;
+  mentionOnly?: boolean;
+  allowedGuilds?: string[];
+}
+
+const MAX_MESSAGE_LENGTH = 2000;
+
+export class DiscordAdapter implements ChannelAdapter {
+  readonly type = 'discord' as const;
+  readonly name = 'Discord';
+
+  private client: Client;
+  private config: DiscordAdapterConfig;
+  private messageHandler?: (message: InboundMessage) => Promise<void>;
+  private errorHandler?: (error: Error) => void;
+  private connected = false;
+
+  constructor(config: DiscordAdapterConfig) {
+    this.config = config;
+    this.client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.DirectMessages,
+        GatewayIntentBits.MessageContent,
+      ],
+      partials: [Partials.Channel, Partials.Message],
+    });
+
+    this.setupEventHandlers();
+  }
+
+  private setupEventHandlers(): void {
+    this.client.on('clientReady', () => {
+      audit('channel.connected', {
+        channelType: 'discord',
+        username: this.client.user?.tag,
+      });
+      this.connected = true;
+    });
+
+    this.client.on('messageCreate', async (message: DiscordMessage) => {
+      // Ignore bot messages
+      if (message.author.bot) return;
+
+      // Check guild allowlist
+      if (
+        message.guild &&
+        this.config.allowedGuilds?.length &&
+        !this.config.allowedGuilds.includes(message.guild.id)
+      ) {
+        return;
+      }
+
+      // Check mention requirement for guild messages
+      if (
+        this.config.mentionOnly &&
+        message.guild &&
+        !message.mentions.has(this.client.user!.id)
+      ) {
+        return;
+      }
+
+      // Convert to inbound message
+      const inbound = this.toInboundMessage(message);
+
+      audit('message.received', {
+        channelType: 'discord',
+        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)));
+        }
+      }
+    });
+
+    this.client.on('error', (error) => {
+      audit('channel.error', { channelType: 'discord', error: error.message });
+      this.errorHandler?.(error);
+    });
+
+    this.client.on('disconnect', () => {
+      this.connected = false;
+      audit('channel.disconnected', { channelType: 'discord' });
+    });
+  }
+
+  private toInboundMessage(message: DiscordMessage): InboundMessage {
+    // Strip bot mention from content
+    let content = message.content;
+    if (this.client.user) {
+      content = content.replace(new RegExp(`<@!?${this.client.user.id}>`, 'g'), '').trim();
+    }
+
+    return {
+      id: message.id,
+      channelType: 'discord',
+      channelId: message.channel.id,
+      senderId: message.author.id,
+      senderName: message.author.displayName || message.author.username,
+      content,
+      timestamp: message.createdTimestamp,
+      replyToId: message.reference?.messageId,
+      attachments: message.attachments.map((a) => ({
+        type: a.contentType?.startsWith('image/')
+          ? 'image'
+          : a.contentType?.startsWith('audio/')
+            ? 'audio'
+            : a.contentType?.startsWith('video/')
+              ? 'video'
+              : 'file',
+        url: a.url,
+        mimeType: a.contentType || undefined,
+        filename: a.name,
+        size: a.size,
+      })),
+      raw: message,
+    };
+  }
+
+  async connect(): Promise<void> {
+    await this.client.login(this.config.token);
+  }
+
+  async disconnect(): Promise<void> {
+    this.client.destroy();
+    this.connected = false;
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  async send(channelId: string, message: OutboundMessage): Promise<SendResult> {
+    try {
+      const channel = await this.client.channels.fetch(channelId);
+
+      if (!channel || !channel.isTextBased() || !('send' in channel)) {
+        return { success: false, error: 'Channel not found or not text-based' };
+      }
+
+      // Chunk long messages
+      const chunks = this.chunkMessage(message.content);
+      let lastMessageId: string | undefined;
+
+      for (const chunk of chunks) {
+        const sent = await channel.send({
+          content: chunk,
+          reply: message.replyToId
+            ? { messageReference: message.replyToId }
+            : undefined,
+        });
+        lastMessageId = sent.id;
+      }
+
+      audit('message.sent', {
+        channelType: 'discord',
+        channelId,
+        messageId: lastMessageId,
+      });
+
+      return { success: true, messageId: lastMessageId };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      audit('channel.error', {
+        channelType: 'discord',
+        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;
+      }
+
+      // Find a good break point
+      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> {
+    // Use cache (populated by messageCreate) to avoid extra API call
+    const channel = this.client.channels.cache.get(channelId);
+    if (!channel || !channel.isTextBased() || !('sendTyping' in channel)) {
+      return () => {};
+    }
+    // Send immediately, then repeat every 8s (Discord typing expires after ~10s)
+    let stopped = false;
+    channel.sendTyping().catch((e: Error) => {
+      audit('channel.error', { channelType: 'discord', action: 'typing', error: e.message });
+    });
+    const interval = setInterval(() => {
+      if (stopped) return;
+      channel.sendTyping().catch(() => {});
+    }, 8000);
+    return () => {
+      stopped = true;
+      clearInterval(interval);
+    };
+  }
+
+  onMessage(handler: (message: InboundMessage) => Promise<void>): void {
+    this.messageHandler = handler;
+  }
+
+  onError(handler: (error: Error) => void): void {
+    this.errorHandler = handler;
+  }
+}