@auxiora/channels 1.0.0

package/src/adapters/matrix.ts

@@ -0,0 +1,376 @@
+import { audit } from '@auxiora/audit';
+import type {
+  ChannelAdapter,
+  InboundMessage,
+  OutboundMessage,
+  SendResult,
+} from '../types.js';
+
+export interface MatrixAdapterConfig {
+  homeserverUrl: string;
+  userId: string;
+  accessToken: string;
+  autoJoinRooms?: boolean;
+  allowedUsers?: string[];
+  allowedRooms?: string[];
+}
+
+interface MatrixSyncResponse {
+  next_batch: string;
+  rooms?: {
+    join?: Record<string, MatrixJoinedRoom>;
+    invite?: Record<string, MatrixInvitedRoom>;
+  };
+}
+
+interface MatrixJoinedRoom {
+  timeline?: {
+    events?: MatrixEvent[];
+  };
+}
+
+interface MatrixInvitedRoom {
+  invite_state?: {
+    events?: MatrixEvent[];
+  };
+}
+
+interface MatrixEvent {
+  event_id: string;
+  type: string;
+  sender: string;
+  origin_server_ts: number;
+  content: {
+    msgtype?: string;
+    body?: string;
+    'm.relates_to'?: {
+      'm.in_reply_to'?: {
+        event_id: string;
+      };
+    };
+    url?: string;
+    info?: {
+      mimetype?: string;
+      size?: number;
+    };
+    filename?: string;
+    membership?: string;
+  };
+}
+
+interface MatrixSendResponse {
+  event_id: string;
+}
+
+const MAX_MESSAGE_LENGTH = 65536;
+
+export class MatrixAdapter implements ChannelAdapter {
+  readonly type = 'matrix' as const;
+  readonly name = 'Matrix';
+
+  private config: MatrixAdapterConfig;
+  private messageHandler?: (message: InboundMessage) => Promise<void>;
+  private errorHandler?: (error: Error) => void;
+  private connected = false;
+  private syncToken?: string;
+  private syncAbort?: AbortController;
+  private syncLoopRunning = false;
+
+  constructor(config: MatrixAdapterConfig) {
+    this.config = config;
+  }
+
+  private get baseUrl(): string {
+    const url = this.config.homeserverUrl.replace(/\/+$/, '');
+    return `${url}/_matrix/client/v3`;
+  }
+
+  private get headers(): Record<string, string> {
+    return {
+      'Authorization': `Bearer ${this.config.accessToken}`,
+      'Content-Type': 'application/json',
+    };
+  }
+
+  private async matrixFetch<T>(
+    path: string,
+    options: RequestInit = {},
+  ): Promise<T> {
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: { ...this.headers, ...(options.headers as Record<string, string> || {}) },
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => response.statusText);
+      throw new Error(`Matrix API error ${response.status}: ${errorText}`);
+    }
+
+    return response.json() as Promise<T>;
+  }
+
+  async connect(): Promise<void> {
+    // Verify credentials by calling whoami
+    await this.matrixFetch('/account/whoami');
+    this.connected = true;
+
+    audit('channel.connected', {
+      channelType: 'matrix',
+      userId: this.config.userId,
+    });
+
+    // Start sync loop
+    this.startSyncLoop();
+  }
+
+  async disconnect(): Promise<void> {
+    this.syncLoopRunning = false;
+    this.syncAbort?.abort();
+    this.connected = false;
+    audit('channel.disconnected', { channelType: 'matrix' });
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  private startSyncLoop(): void {
+    this.syncLoopRunning = true;
+    void this.syncLoop();
+  }
+
+  private async syncLoop(): Promise<void> {
+    while (this.syncLoopRunning && this.connected) {
+      try {
+        this.syncAbort = new AbortController();
+        const params = new URLSearchParams({
+          timeout: '30000',
+        });
+
+        if (this.syncToken) {
+          params.set('since', this.syncToken);
+        }
+
+        const response = await this.matrixFetch<MatrixSyncResponse>(
+          `/sync?${params.toString()}`,
+          { signal: this.syncAbort.signal },
+        );
+
+        // Handle invites (auto-join)
+        if (this.config.autoJoinRooms && response.rooms?.invite) {
+          for (const roomId of Object.keys(response.rooms.invite)) {
+            try {
+              await this.matrixFetch(`/rooms/${encodeURIComponent(roomId)}/join`, {
+                method: 'POST',
+                body: '{}',
+              });
+            } catch {
+              // Ignore join failures
+            }
+          }
+        }
+
+        // Process messages from joined rooms
+        if (response.rooms?.join) {
+          for (const [roomId, room] of Object.entries(response.rooms.join)) {
+            const events = room.timeline?.events || [];
+            for (const event of events) {
+              await this.handleEvent(roomId, event);
+            }
+          }
+        }
+
+        this.syncToken = response.next_batch;
+      } catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+          break;
+        }
+        this.errorHandler?.(error instanceof Error ? error : new Error(String(error)));
+        // Brief delay before retrying on error
+        await new Promise((resolve) => setTimeout(resolve, 5000));
+      }
+    }
+  }
+
+  private async handleEvent(roomId: string, event: MatrixEvent): Promise<void> {
+    // Only process m.room.message events
+    if (event.type !== 'm.room.message') return;
+
+    // Ignore own messages
+    if (event.sender === this.config.userId) return;
+
+    // Only process text and notice messages
+    const msgtype = event.content.msgtype;
+    if (msgtype !== 'm.text' && msgtype !== 'm.notice') return;
+
+    // Check allowed rooms
+    if (this.config.allowedRooms?.length && !this.config.allowedRooms.includes(roomId)) {
+      audit('message.filtered', { channelType: 'matrix', senderId: event.sender, roomId, reason: 'room_not_allowed' });
+      return;
+    }
+
+    // Check allowed users
+    if (this.config.allowedUsers?.length && !this.config.allowedUsers.includes(event.sender)) {
+      audit('message.filtered', { channelType: 'matrix', senderId: event.sender, roomId, reason: 'user_not_allowed' });
+      return;
+    }
+
+    const inbound = this.toInboundMessage(roomId, event);
+
+    audit('message.received', {
+      channelType: 'matrix',
+      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(roomId: string, event: MatrixEvent): InboundMessage {
+    const replyTo = event.content['m.relates_to']?.['m.in_reply_to']?.event_id;
+
+    // Strip reply fallback from content if present
+    let content = event.content.body || '';
+    if (replyTo && content.startsWith('> ')) {
+      const lines = content.split('\n');
+      const nonQuoteIdx = lines.findIndex((l) => !l.startsWith('> ') && l !== '');
+      if (nonQuoteIdx > 0) {
+        content = lines.slice(nonQuoteIdx).join('\n').trim();
+      }
+    }
+
+    return {
+      id: event.event_id,
+      channelType: 'matrix',
+      channelId: roomId,
+      senderId: event.sender,
+      senderName: event.sender.split(':')[0].replace('@', ''),
+      content,
+      timestamp: event.origin_server_ts,
+      replyToId: replyTo,
+      raw: event,
+    };
+  }
+
+  async send(channelId: string, message: OutboundMessage): Promise<SendResult> {
+    try {
+      const chunks = this.chunkMessage(message.content);
+      let lastEventId: string | undefined;
+
+      for (const chunk of chunks) {
+        const txnId = `m${Date.now()}.${Math.random().toString(36).slice(2)}`;
+        const body: Record<string, unknown> = {
+          msgtype: 'm.text',
+          body: chunk,
+        };
+
+        // Add reply relation
+        if (message.replyToId) {
+          body['m.relates_to'] = {
+            'm.in_reply_to': {
+              event_id: message.replyToId,
+            },
+          };
+        }
+
+        const result = await this.matrixFetch<MatrixSendResponse>(
+          `/rooms/${encodeURIComponent(channelId)}/send/m.room.message/${encodeURIComponent(txnId)}`,
+          { method: 'PUT', body: JSON.stringify(body) },
+        );
+
+        lastEventId = result.event_id;
+      }
+
+      audit('message.sent', {
+        channelType: 'matrix',
+        channelId,
+        messageId: lastEventId,
+      });
+
+      return { success: true, messageId: lastEventId };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      audit('channel.error', {
+        channelType: 'matrix',
+        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> {
+    const userId = this.config.userId;
+    const typingPath = `/rooms/${encodeURIComponent(channelId)}/typing/${encodeURIComponent(userId)}`;
+
+    // Send typing with 30s timeout, repeat every 25s
+    let stopped = false;
+    const sendTyping = () =>
+      this.matrixFetch(typingPath, {
+        method: 'PUT',
+        body: JSON.stringify({ typing: true, timeout: 30000 }),
+      }).catch((e: Error) => {
+        audit('channel.error', { channelType: 'matrix', action: 'typing', error: e.message });
+      });
+
+    sendTyping();
+    const interval = setInterval(() => {
+      if (stopped) return;
+      sendTyping();
+    }, 25000);
+
+    return () => {
+      stopped = true;
+      clearInterval(interval);
+      // Send stop-typing signal
+      this.matrixFetch(typingPath, {
+        method: 'PUT',
+        body: JSON.stringify({ typing: false }),
+      }).catch(() => {});
+    };
+  }
+
+  onMessage(handler: (message: InboundMessage) => Promise<void>): void {
+    this.messageHandler = handler;
+  }
+
+  onError(handler: (error: Error) => void): void {
+    this.errorHandler = handler;
+  }
+}

package/src/adapters/signal.ts

@@ -0,0 +1,313 @@
+import { audit } from '@auxiora/audit';
+import type {
+  ChannelAdapter,
+  InboundMessage,
+  OutboundMessage,
+  SendResult,
+} from '../types.js';
+
+export interface SignalAdapterConfig {
+  signalCliEndpoint: string;
+  phoneNumber: string;
+  allowedNumbers?: string[];
+}
+
+interface SignalJsonRpcResponse<T = unknown> {
+  jsonrpc: '2.0';
+  id: number;
+  result?: T;
+  error?: {
+    code: number;
+    message: string;
+  };
+}
+
+interface SignalMessage {
+  envelope: {
+    source: string;
+    sourceName?: string;
+    sourceNumber?: string;
+    timestamp: number;
+    dataMessage?: {
+      message: string;
+      timestamp: number;
+      groupInfo?: {
+        groupId: string;
+        type?: string;
+      };
+      attachments?: Array<{
+        contentType: string;
+        filename?: string;
+        size?: number;
+        id?: string;
+      }>;
+      quote?: {
+        id: number;
+        author: string;
+        text: string;
+      };
+    };
+  };
+}
+
+interface SignalSendResult {
+  timestamp: number;
+  results?: Array<{
+    recipientAddress: { number: string };
+    type: string;
+  }>;
+}
+
+const MAX_MESSAGE_LENGTH = 6000;
+
+export class SignalAdapter implements ChannelAdapter {
+  readonly type = 'signal' as const;
+  readonly name = 'Signal';
+
+  private config: SignalAdapterConfig;
+  private messageHandler?: (message: InboundMessage) => Promise<void>;
+  private errorHandler?: (error: Error) => void;
+  private connected = false;
+  private pollRunning = false;
+  private pollAbort?: AbortController;
+  private rpcId = 0;
+
+  constructor(config: SignalAdapterConfig) {
+    this.config = config;
+  }
+
+  private get endpoint(): string {
+    return this.config.signalCliEndpoint.replace(/\/+$/, '');
+  }
+
+  private async rpcCall<T>(method: string, params: Record<string, unknown> = {}): Promise<T> {
+    this.rpcId++;
+    const body = {
+      jsonrpc: '2.0',
+      id: this.rpcId,
+      method,
+      params: { ...params, account: this.config.phoneNumber },
+    };
+
+    const response = await fetch(`${this.endpoint}/api/v1/rpc`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Signal CLI API error ${response.status}: ${response.statusText}`);
+    }
+
+    const result = await response.json() as SignalJsonRpcResponse<T>;
+
+    if (result.error) {
+      throw new Error(`Signal CLI RPC error: ${result.error.message}`);
+    }
+
+    return result.result as T;
+  }
+
+  async connect(): Promise<void> {
+    // Verify connection by listing accounts
+    await this.rpcCall('listAccounts');
+    this.connected = true;
+
+    audit('channel.connected', {
+      channelType: 'signal',
+      phoneNumber: this.config.phoneNumber,
+    });
+
+    this.startPolling();
+  }
+
+  async disconnect(): Promise<void> {
+    this.pollRunning = false;
+    this.pollAbort?.abort();
+    this.connected = false;
+    audit('channel.disconnected', { channelType: 'signal' });
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  private startPolling(): void {
+    this.pollRunning = true;
+    void this.pollLoop();
+  }
+
+  private async pollLoop(): Promise<void> {
+    while (this.pollRunning && this.connected) {
+      try {
+        this.pollAbort = new AbortController();
+
+        const messages = await this.rpcCall<SignalMessage[]>('receive');
+
+        if (messages && Array.isArray(messages)) {
+          for (const msg of messages) {
+            await this.handleMessage(msg);
+          }
+        }
+
+        // Brief delay between polls
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      } catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+          break;
+        }
+        this.errorHandler?.(error instanceof Error ? error : new Error(String(error)));
+        await new Promise((resolve) => setTimeout(resolve, 5000));
+      }
+    }
+  }
+
+  private async handleMessage(msg: SignalMessage): Promise<void> {
+    const dataMessage = msg.envelope.dataMessage;
+    if (!dataMessage || !dataMessage.message) return;
+
+    // Ignore own messages
+    if (msg.envelope.source === this.config.phoneNumber ||
+        msg.envelope.sourceNumber === this.config.phoneNumber) {
+      return;
+    }
+
+    // Check allowed numbers
+    const senderNumber = msg.envelope.sourceNumber || msg.envelope.source;
+    if (this.config.allowedNumbers?.length && !this.config.allowedNumbers.includes(senderNumber)) {
+      audit('message.filtered', { channelType: 'signal', senderId: senderNumber, reason: 'number_not_allowed' });
+      return;
+    }
+
+    const inbound = this.toInboundMessage(msg);
+
+    audit('message.received', {
+      channelType: 'signal',
+      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: SignalMessage): InboundMessage {
+    const dataMessage = msg.envelope.dataMessage!;
+    const isGroup = !!dataMessage.groupInfo;
+    const channelId = isGroup
+      ? dataMessage.groupInfo!.groupId
+      : msg.envelope.sourceNumber || msg.envelope.source;
+
+    return {
+      id: String(dataMessage.timestamp),
+      channelType: 'signal',
+      channelId,
+      senderId: msg.envelope.sourceNumber || msg.envelope.source,
+      senderName: msg.envelope.sourceName,
+      content: dataMessage.message,
+      timestamp: dataMessage.timestamp,
+      replyToId: dataMessage.quote ? String(dataMessage.quote.id) : undefined,
+      attachments: dataMessage.attachments?.map((a) => ({
+        type: a.contentType.startsWith('image/')
+          ? 'image' as const
+          : a.contentType.startsWith('audio/')
+            ? 'audio' as const
+            : a.contentType.startsWith('video/')
+              ? 'video' as const
+              : 'file' as const,
+        mimeType: a.contentType,
+        filename: a.filename,
+        size: a.size,
+      })),
+      raw: msg,
+    };
+  }
+
+  async send(channelId: string, message: OutboundMessage): Promise<SendResult> {
+    try {
+      const chunks = this.chunkMessage(message.content);
+      let lastTimestamp: number | undefined;
+
+      for (const chunk of chunks) {
+        // Determine if group or direct
+        const isGroup = !channelId.startsWith('+');
+
+        const params: Record<string, unknown> = {
+          message: chunk,
+        };
+
+        if (isGroup) {
+          params.groupId = channelId;
+        } else {
+          params.recipient = [channelId];
+        }
+
+        if (message.replyToId) {
+          params.quoteTimestamp = parseInt(message.replyToId, 10);
+          params.quoteAuthor = channelId;
+        }
+
+        const result = await this.rpcCall<SignalSendResult>('send', params);
+        lastTimestamp = result.timestamp;
+      }
+
+      audit('message.sent', {
+        channelType: 'signal',
+        channelId,
+        messageId: lastTimestamp,
+      });
+
+      return { success: true, messageId: String(lastTimestamp) };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      audit('channel.error', {
+        channelType: 'signal',
+        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;
+  }
+}