@auxiora/channels 1.0.0

package/src/index.ts

@@ -0,0 +1,78 @@
+// Types
+export type {
+  ChannelType,
+  ChannelAdapter,
+  ChannelConfig,
+  InboundMessage,
+  OutboundMessage,
+  SendResult,
+  Attachment,
+} from './types.js';
+
+// Adapters
+export {
+  DiscordAdapter,
+  type DiscordAdapterConfig,
+} from './adapters/discord.js';
+
+export {
+  TelegramAdapter,
+  type TelegramAdapterConfig,
+} from './adapters/telegram.js';
+
+export {
+  SlackAdapter,
+  type SlackAdapterConfig,
+} from './adapters/slack.js';
+
+export {
+  TwilioAdapter,
+  type TwilioAdapterConfig,
+  type TwilioWebhookBody,
+} from './adapters/twilio.js';
+
+export {
+  MatrixAdapter,
+  type MatrixAdapterConfig,
+} from './adapters/matrix.js';
+
+export {
+  SignalAdapter,
+  type SignalAdapterConfig,
+} from './adapters/signal.js';
+
+export {
+  EmailAdapter,
+  type EmailAdapterConfig,
+} from './adapters/email.js';
+
+export {
+  TeamsAdapter,
+  type TeamsAdapterConfig,
+} from './adapters/teams.js';
+
+export {
+  WhatsAppAdapter,
+  type WhatsAppAdapterConfig,
+} from './adapters/whatsapp.js';
+
+export {
+  GoogleChatAdapter,
+  type GoogleChatAdapterConfig,
+} from './adapters/googlechat.js';
+
+export {
+  BlueBubblesAdapter,
+  type BlueBubblesAdapterConfig,
+} from './adapters/bluebubbles.js';
+
+export {
+  ZaloAdapter,
+  type ZaloAdapterConfig,
+} from './adapters/zalo.js';
+
+// Manager
+export {
+  ChannelManager,
+  type ChannelManagerConfig,
+} from './manager.js';

package/src/manager.ts

@@ -0,0 +1,180 @@
+import { audit } from '@auxiora/audit';
+import { getLogger } from '@auxiora/logger';
+
+const logger = getLogger('channels');
+import type {
+  ChannelAdapter,
+  ChannelType,
+  ChannelConfig,
+  InboundMessage,
+  OutboundMessage,
+  SendResult,
+} from './types.js';
+import { DiscordAdapter, type DiscordAdapterConfig } from './adapters/discord.js';
+import { TelegramAdapter, type TelegramAdapterConfig } from './adapters/telegram.js';
+import { SlackAdapter, type SlackAdapterConfig } from './adapters/slack.js';
+import { TwilioAdapter, type TwilioAdapterConfig } from './adapters/twilio.js';
+import { GoogleChatAdapter, type GoogleChatAdapterConfig } from './adapters/googlechat.js';
+import { BlueBubblesAdapter, type BlueBubblesAdapterConfig } from './adapters/bluebubbles.js';
+import { ZaloAdapter, type ZaloAdapterConfig } from './adapters/zalo.js';
+
+export interface ChannelManagerConfig {
+  discord?: DiscordAdapterConfig;
+  telegram?: TelegramAdapterConfig;
+  slack?: SlackAdapterConfig;
+  twilio?: TwilioAdapterConfig;
+  googlechat?: GoogleChatAdapterConfig;
+  bluebubbles?: BlueBubblesAdapterConfig;
+  zalo?: ZaloAdapterConfig;
+}
+
+export class ChannelManager {
+  private adapters: Map<ChannelType, ChannelAdapter> = new Map();
+  private messageHandler?: (message: InboundMessage) => Promise<void>;
+  private errorHandler?: (error: Error, channelType: ChannelType) => void;
+
+  constructor(config: ChannelManagerConfig) {
+    // Initialize configured adapters
+    if (config.discord?.token) {
+      this.adapters.set('discord', new DiscordAdapter(config.discord));
+    }
+
+    if (config.telegram?.token) {
+      this.adapters.set('telegram', new TelegramAdapter(config.telegram));
+    }
+
+    if (config.slack?.botToken && config.slack?.appToken) {
+      this.adapters.set('slack', new SlackAdapter(config.slack));
+    }
+
+    if (config.twilio?.accountSid && config.twilio?.authToken) {
+      this.adapters.set('twilio', new TwilioAdapter(config.twilio));
+    }
+
+    if (config.googlechat?.serviceAccountKey) {
+      this.adapters.set('googlechat', new GoogleChatAdapter(config.googlechat));
+    }
+
+    if (config.bluebubbles?.serverUrl && config.bluebubbles?.password) {
+      this.adapters.set('bluebubbles', new BlueBubblesAdapter(config.bluebubbles));
+    }
+
+    if (config.zalo?.oaAccessToken && config.zalo?.oaSecretKey) {
+      this.adapters.set('zalo', new ZaloAdapter(config.zalo));
+    }
+  }
+
+  async connectAll(): Promise<void> {
+    const results = await Promise.allSettled(
+      Array.from(this.adapters.entries()).map(async ([type, adapter]) => {
+        try {
+          // Set up message handler
+          adapter.onMessage(async (message) => {
+            if (this.messageHandler) {
+              await this.messageHandler(message);
+            }
+          });
+
+          // Set up error handler
+          adapter.onError((error) => {
+            if (this.errorHandler) {
+              this.errorHandler(error, type);
+            }
+          });
+
+          await adapter.connect();
+          logger.info(`Connected to ${adapter.name}`);
+        } catch (error) {
+          logger.error(`Failed to connect to ${adapter.name}`, { error: error instanceof Error ? error : new Error(String(error)) });
+          throw error;
+        }
+      })
+    );
+
+    const failures = results.filter((r) => r.status === 'rejected');
+    if (failures.length > 0) {
+      logger.warn(`${failures.length} channel(s) failed to connect`);
+    }
+  }
+
+  async disconnectAll(): Promise<void> {
+    await Promise.allSettled(
+      Array.from(this.adapters.values()).map((adapter) => adapter.disconnect())
+    );
+  }
+
+  async connect(type: ChannelType): Promise<void> {
+    const adapter = this.adapters.get(type);
+    if (!adapter) {
+      throw new Error(`Channel not configured: ${type}`);
+    }
+
+    adapter.onMessage(async (message) => {
+      if (this.messageHandler) {
+        await this.messageHandler(message);
+      }
+    });
+
+    adapter.onError((error) => {
+      if (this.errorHandler) {
+        this.errorHandler(error, type);
+      }
+    });
+
+    await adapter.connect();
+  }
+
+  async disconnect(type: ChannelType): Promise<void> {
+    const adapter = this.adapters.get(type);
+    if (adapter) {
+      await adapter.disconnect();
+    }
+  }
+
+  async send(
+    channelType: ChannelType,
+    channelId: string,
+    message: OutboundMessage
+  ): Promise<SendResult> {
+    const adapter = this.adapters.get(channelType);
+    if (!adapter) {
+      return { success: false, error: `Channel not configured: ${channelType}` };
+    }
+
+    if (!adapter.isConnected()) {
+      return { success: false, error: `Channel not connected: ${channelType}` };
+    }
+
+    return adapter.send(channelId, message);
+  }
+
+  async startTyping(channelType: ChannelType, channelId: string): Promise<() => void> {
+    const adapter = this.adapters.get(channelType);
+    if (!adapter?.startTyping || !adapter.isConnected()) {
+      return () => {};
+    }
+    return adapter.startTyping(channelId);
+  }
+
+  getAdapter<T extends ChannelAdapter>(type: ChannelType): T | undefined {
+    return this.adapters.get(type) as T | undefined;
+  }
+
+  getConnectedChannels(): ChannelType[] {
+    return Array.from(this.adapters.entries())
+      .filter(([_, adapter]) => adapter.isConnected())
+      .map(([type]) => type);
+  }
+
+  getConfiguredChannels(): ChannelType[] {
+    return Array.from(this.adapters.keys());
+  }
+
+  onMessage(handler: (message: InboundMessage) => Promise<void>): void {
+    this.messageHandler = handler;
+  }
+
+  onError(handler: (error: Error, channelType: ChannelType) => void): void {
+    this.errorHandler = handler;
+  }
+}

package/src/types.ts

@@ -0,0 +1,84 @@
+export type ChannelType = 'discord' | 'telegram' | 'slack' | 'twilio' | 'webchat' | 'matrix' | 'signal' | 'email' | 'teams' | 'whatsapp' | 'googlechat' | 'bluebubbles' | 'zalo';
+
+export interface InboundMessage {
+  id: string;
+  channelType: ChannelType;
+  channelId: string;         // Server/chat ID
+  senderId: string;          // User ID
+  senderName?: string;       // Display name
+  content: string;
+  timestamp: number;
+  replyToId?: string;        // If replying to a message
+  attachments?: Attachment[];
+  raw?: unknown;             // Original platform message
+}
+
+export interface Attachment {
+  type: 'image' | 'audio' | 'video' | 'file';
+  url?: string;
+  data?: Buffer;
+  mimeType?: string;
+  filename?: string;
+  size?: number;
+}
+
+export interface OutboundMessage {
+  content: string;
+  replyToId?: string;
+  attachments?: Attachment[];
+  formatting?: {
+    markdown?: boolean;
+    html?: boolean;
+  };
+}
+
+export interface SendResult {
+  success: boolean;
+  messageId?: string;
+  error?: string;
+}
+
+export interface ChannelAdapter {
+  readonly type: ChannelType;
+  readonly name: string;
+
+  // Lifecycle
+  connect(): Promise<void>;
+  disconnect(): Promise<void>;
+  isConnected(): boolean;
+
+  // Messaging
+  send(channelId: string, message: OutboundMessage): Promise<SendResult>;
+
+  // Typing indicator — returns a cleanup function to stop the indicator
+  startTyping?(channelId: string): Promise<() => void>;
+
+  // Events
+  onMessage(handler: (message: InboundMessage) => Promise<void>): void;
+  onError(handler: (error: Error) => void): void;
+}
+
+export interface ChannelConfig {
+  discord?: {
+    token: string;
+    mentionOnly?: boolean;
+    allowedGuilds?: string[];
+  };
+  telegram?: {
+    token: string;
+    webhookUrl?: string;
+    allowedChats?: string[];
+  };
+  slack?: {
+    botToken: string;
+    appToken: string;
+    signingSecret?: string;
+  };
+  twilio?: {
+    accountSid: string;
+    authToken: string;
+    phoneNumber: string;        // Your Twilio phone number
+    webhookUrl?: string;        // For incoming messages
+    whatsappNumber?: string;    // WhatsApp-enabled number
+  };
+}