@johpaz/hive 1.1.0

package/packages/core/src/channels/discord.ts

@@ -0,0 +1,260 @@
+import {
+  Client,
+  GatewayIntentBits,
+  Events,
+  type Message,
+  type TextChannel,
+  type DMChannel,
+  type NewsChannel,
+} from "discord.js";
+import { BaseChannel, type ChannelConfig, type IncomingMessage, type OutboundMessage } from "./base.ts";
+import { logger } from "../utils/logger.ts";
+
+export interface DiscordConfig extends ChannelConfig {
+  botToken: string;
+  applicationId?: string;
+  guilds?: Record<string, unknown>;
+}
+
+type DiscordTextChannel = TextChannel | DMChannel | NewsChannel;
+
+export class DiscordChannel extends BaseChannel {
+  name = "discord";
+  accountId: string;
+  config: DiscordConfig;
+  
+  private client?: Client;
+  private log = logger.child("discord");
+  private channelCache: Map<string, DiscordTextChannel> = new Map();
+
+  constructor(accountId: string, config: DiscordConfig) {
+    super();
+    this.accountId = accountId;
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    if (!this.config.botToken) {
+      throw new Error("Discord bot token not configured");
+    }
+
+    this.client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.DirectMessages,
+        GatewayIntentBits.MessageContent,
+      ],
+    });
+
+    this.client.on(Events.MessageCreate, async (message) => {
+      await this.handleDiscordMessage(message);
+    });
+
+    this.client.on(Events.Error, (error) => {
+      this.log.error(`Discord client error: ${error.message}`);
+    });
+
+    this.client.once(Events.ClientReady, () => {
+      this.log.info(`Discord bot started: ${this.client?.user?.tag ?? "unknown"}`);
+      this.running = true;
+    });
+
+    try {
+      await this.client.login(this.config.botToken);
+    } catch (error) {
+      this.log.error(`Failed to login to Discord: ${(error as Error).message}`);
+      throw error;
+    }
+  }
+
+  private async handleDiscordMessage(message: Message): Promise<void> {
+    if (message.author.bot) return;
+
+    const isGuild = message.guild !== null;
+    const kind = isGuild ? "group" : "direct";
+    const peerId = isGuild 
+      ? `${message.guildId}:${message.channelId}:${message.author.id}`
+      : message.author.id;
+
+    if (!isGuild && !this.isUserAllowed(message.author.id)) {
+      this.log.debug(`Message from unauthorized user: ${message.author.id}`);
+      return;
+    }
+
+    const sessionId = this.formatSessionId(peerId, kind);
+    if (message.channel.isTextBased()) {
+      this.channelCache.set(sessionId, message.channel as DiscordTextChannel);
+    }
+
+    const audioAttachment = message.attachments.find(a => 
+      a.contentType?.startsWith("audio/") || 
+      a.url.endsWith(".mp3") ||
+      a.url.endsWith(".ogg") ||
+      a.url.endsWith(".webm") ||
+      a.url.endsWith(".wav")
+    );
+
+    const incomingMessage: IncomingMessage = {
+      sessionId,
+      channel: "discord",
+      accountId: this.accountId,
+      peerId,
+      peerKind: kind,
+      content: message.content || "",
+      audio: audioAttachment ? { url: audioAttachment.url, mimeType: audioAttachment.contentType || "audio/webm" } : undefined,
+      metadata: {
+        discord: {
+          guildId: message.guildId,
+          channelId: message.channelId,
+          userId: message.author.id,
+          username: message.author.username,
+          messageId: message.id,
+          roles: message.member?.roles.cache.map(r => r.id),
+        },
+      },
+      replyToId: message.reference?.messageId 
+        ? `discord:${message.reference.messageId}` 
+        : undefined,
+    };
+
+    await this.handleMessage(incomingMessage);
+  }
+
+  async stop(): Promise<void> {
+    if (this.client) {
+      this.client.destroy();
+      this.running = false;
+      this.log.info("Discord bot stopped");
+    }
+  }
+
+  private async getChannel(sessionId: string): Promise<DiscordTextChannel | null> {
+    const cached = this.channelCache.get(sessionId);
+    if (cached) return cached;
+
+    if (!this.client) return null;
+
+    const parts = sessionId.split(":");
+    const peerPart = parts.slice(3).join(":");
+    
+    let channelId: string;
+    if (peerPart.includes(":")) {
+      const channelPart = peerPart.split(":");
+      channelId = channelPart[1] ?? peerPart;
+    } else {
+      channelId = peerPart;
+    }
+
+    try {
+      const channel = await this.client.channels.fetch(channelId);
+      if (channel && channel.isTextBased()) {
+        this.channelCache.set(sessionId, channel as DiscordTextChannel);
+        return channel as DiscordTextChannel;
+      }
+    } catch {
+      // Channel not found
+    }
+
+    return null;
+  }
+
+  async startTyping(sessionId: string): Promise<void> {
+    const channel = await this.getChannel(sessionId);
+    if (!channel) return;
+
+    await channel.sendTyping();
+
+    const interval = setInterval(async () => {
+      try {
+        await channel.sendTyping();
+      } catch {
+        this.stopTyping(sessionId);
+      }
+    }, 8000);
+
+    this.typingIntervals.set(sessionId, interval);
+  }
+
+  async stopTyping(sessionId: string): Promise<void> {
+    const interval = this.typingIntervals.get(sessionId);
+    if (interval) {
+      clearInterval(interval);
+      this.typingIntervals.delete(sessionId);
+    }
+  }
+
+  async send(sessionId: string, message: OutboundMessage): Promise<void> {
+    await this.stopTyping(sessionId);
+
+    const channel = await this.getChannel(sessionId);
+    
+    if (!channel) {
+      throw new Error(`Channel not found for session: ${sessionId}`);
+    }
+
+    const content = message.content ?? "";
+    const maxLength = 2000;
+
+    try {
+      if (content.length <= maxLength) {
+        await channel.send(content);
+      } else {
+        const chunks = this.chunkMessage(content, maxLength);
+        for (const chunk of chunks) {
+          await channel.send(chunk);
+        }
+      }
+    } catch (error) {
+      this.log.error(`Failed to send Discord message: ${(error as Error).message}`);
+      throw error;
+    }
+  }
+
+  private chunkMessage(content: string, maxLength: number): string[] {
+    const chunks: string[] = [];
+    let remaining = content;
+
+    while (remaining.length > 0) {
+      if (remaining.length <= maxLength) {
+        chunks.push(remaining);
+        break;
+      }
+
+      let splitPoint = remaining.lastIndexOf("\n", maxLength);
+      if (splitPoint === -1 || splitPoint < maxLength * 0.5) {
+        splitPoint = remaining.lastIndexOf(" ", maxLength);
+      }
+      if (splitPoint === -1 || splitPoint < maxLength * 0.5) {
+        splitPoint = maxLength;
+      }
+
+      chunks.push(remaining.slice(0, splitPoint));
+      remaining = remaining.slice(splitPoint).trim();
+    }
+
+    return chunks;
+  }
+
+  async sendAudio(sessionId: string, audio: Buffer, mimeType: string): Promise<void> {
+    const channel = await this.getChannel(sessionId);
+    
+    if (!channel) {
+      throw new Error(`Channel not found for session: ${sessionId}`);
+    }
+
+    try {
+      const attachmentName = `response.${mimeType === "audio/mpeg" ? "mp3" : "ogg"}`;
+      await channel.send({
+        files: [{ attachment: audio, name: attachmentName }]
+      });
+    } catch (error) {
+      this.log.error(`Failed to send Discord audio: ${(error as Error).message}`);
+      throw error;
+    }
+  }
+}
+
+export function createDiscordChannel(accountId: string, config: DiscordConfig): DiscordChannel {
+  return new DiscordChannel(accountId, config);
+}

package/packages/core/src/channels/index.ts

@@ -0,0 +1,7 @@
+export * from "./base.ts";
+export * from "./telegram.ts";
+export * from "./discord.ts";
+export * from "./webchat.ts";
+export * from "./whatsapp.ts";
+export * from "./slack.ts";
+export * from "./manager.ts";

package/packages/core/src/channels/manager.ts

@@ -0,0 +1,383 @@
+import type { Config } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+import type { IChannel, IncomingMessage, MessageHandler } from "./base.ts";
+import { createTelegramChannel, type TelegramConfig } from "./telegram.ts";
+import { createDiscordChannel, type DiscordConfig } from "./discord.ts";
+import { createWebChatChannel, type WebChatConfig } from "./webchat.ts";
+import { createWhatsAppChannel, type WhatsAppConfig } from "./whatsapp.ts";
+import { createSlackChannel, type SlackConfig } from "./slack.ts";
+import { getDb } from "../storage/sqlite.ts";
+import { decryptConfig } from "../storage/crypto.ts";
+
+export class ChannelManager {
+  private config: Config;
+  private channels: Map<string, IChannel> = new Map();
+  private messageHandler?: MessageHandler;
+  private log = logger.child("channels");
+
+  constructor(config: Config) {
+    this.config = config;
+  }
+
+  onMessage(handler: MessageHandler): void {
+    this.messageHandler = handler;
+  }
+
+  async initialize(): Promise<void> {
+    // Primero, intentar cargar canales desde la BD
+    await this.initializeFromDB();
+
+    // Si no hay canales en la BD, usar config
+    if (this.channels.size === 0) {
+      await this.initializeFromConfig();
+    }
+
+    this.log.info(`Initialized ${this.channels.size} channel(s)`);
+  }
+
+  private async initializeFromDB(): Promise<void> {
+    try {
+      const db = getDb();
+      // Load all active channels - config may be empty for webchat
+      const rows = db.query(`
+        SELECT id, type, config_encrypted, config_iv, enabled, active
+        FROM channels
+        WHERE enabled = 1 AND active = 1
+      `).all() as Array<{
+        id: string;
+        type: string;
+        config_encrypted: string | null;
+        config_iv: string | null;
+        enabled: number;
+        active: number;
+      }>;
+
+      for (const row of rows) {
+        let config: Record<string, unknown> = {};
+
+        if (row.config_encrypted && row.config_iv) {
+          try {
+            config = await decryptConfig(row.config_encrypted, row.config_iv);
+            this.log.debug(`Decrypted config for ${row.type}:${row.id}:`, Object.keys(config));
+          } catch (error) {
+            this.log.warn(`Failed to decrypt config for channel ${row.id}:`, (error as Error).message);
+          }
+        }
+
+        // Use channel id as accountId
+        const accountId = row.id;
+        this.log.info(`Creating channel ${row.type}:${accountId} with config keys:`, Object.keys(config));
+        await this.createChannel(row.type, accountId, config);
+      }
+    } catch (error) {
+      this.log.debug("No channels found in DB or DB not initialized:", (error as Error).message);
+    }
+  }
+
+  private async initializeFromConfig(): Promise<void> {
+    const channelConfigs = this.config.channels ?? {};
+
+    for (const [channelName, channelConfig] of Object.entries(channelConfigs)) {
+      // If enabled is explicitly false, skip
+      if (channelConfig.enabled === false) {
+        this.log.debug(`Channel ${channelName} is disabled`);
+        continue;
+      }
+
+      const accounts = channelConfig.accounts;
+      if (!accounts || Object.keys(accounts).length === 0) {
+        this.log.warn(`Channel ${channelName} has no accounts configured`);
+        continue;
+      }
+
+      for (const [accountId, accountConfig] of Object.entries(accounts)) {
+        const fullConfig = { ...channelConfig, ...accountConfig };
+        await this.createChannel(channelName, accountId, fullConfig);
+      }
+    }
+  }
+
+  private async createChannel(
+    channelName: string,
+    accountId: string,
+    config: Record<string, unknown>
+  ): Promise<void> {
+    let channel: IChannel;
+
+    try {
+      switch (channelName) {
+        case "telegram":
+          channel = createTelegramChannel(accountId, {
+            enabled: true,
+            botToken: config.botToken as string,
+            dmPolicy: (config.dmPolicy as "open" | "pairing" | "allowlist") ?? "open",
+            allowFrom: (config.allowFrom as string[]) ?? [],
+            groups: (config.groups as boolean) ?? false,
+          } as TelegramConfig);
+          break;
+
+        case "discord":
+          channel = createDiscordChannel(accountId, {
+            enabled: true,
+            botToken: config.botToken as string,
+            applicationId: config.applicationId as string,
+            dmPolicy: (config.dmPolicy as "open" | "pairing" | "allowlist") ?? "allowlist",
+            allowFrom: (config.allowFrom as string[]) ?? [],
+          } as DiscordConfig);
+          break;
+
+        case "webchat":
+          channel = createWebChatChannel({
+            enabled: true,
+            dmPolicy: "open",
+            allowFrom: [],
+          } as WebChatConfig);
+          break;
+
+        case "whatsapp":
+          channel = createWhatsAppChannel({
+            enabled: true,
+            accountId,
+            agentId: (config.agentId as string) ?? "main",
+            dmPolicy: (config.dmPolicy as "open" | "pairing" | "allowlist") ?? "allowlist",
+            allowFrom: (config.allowFrom as string[]) ?? [],
+            reconnectMaxAttempts: (config.reconnectMaxAttempts as number) ?? 10,
+            reconnectBaseDelayMs: (config.reconnectBaseDelayMs as number) ?? 5000,
+          } as WhatsAppConfig);
+          break;
+
+        case "slack":
+          channel = createSlackChannel({
+            enabled: true,
+            botToken: config.botToken as string,
+            appToken: config.appToken as string,
+            signingSecret: config.signingSecret as string,
+            port: (config.port as number) ?? 3000,
+            dmPolicy: (config.dmPolicy as "open" | "pairing" | "allowlist") ?? "allowlist",
+            allowFrom: (config.allowFrom as string[]) ?? [],
+          } as SlackConfig);
+          break;
+
+        default:
+          this.log.warn(`Unknown channel type: ${channelName}`);
+          return;
+      }
+
+      channel.onMessage(async (message: IncomingMessage) => {
+        if (this.messageHandler) {
+          await this.messageHandler(message);
+        }
+      });
+
+      const key = `${channelName}:${accountId}`;
+      this.channels.set(key, channel);
+
+      this.log.info(`Created channel: ${key}`);
+    } catch (error) {
+      this.log.error(`Failed to create channel ${channelName}:${accountId}: ${(error as Error).message}`);
+    }
+  }
+
+  async startAll(): Promise<void> {
+    const promises: Promise<void>[] = [];
+
+    for (const [key, channel] of this.channels) {
+      if (channel.isRunning()) {
+        this.log.info(`Channel ${key} is already running, skipping`);
+        continue;
+      }
+      promises.push(
+        channel.start().catch((error) => {
+          this.log.error(`Failed to start channel ${key}: ${error.message}`);
+        })
+      );
+    }
+
+    await Promise.allSettled(promises);
+    this.log.info("All channels started");
+  }
+
+  async stopAll(): Promise<void> {
+    const promises: Promise<void>[] = [];
+
+    for (const [key, channel] of this.channels) {
+      promises.push(
+        channel.stop().catch((error) => {
+          this.log.error(`Failed to stop channel ${key}: ${error.message}`);
+        })
+      );
+    }
+
+    await Promise.allSettled(promises);
+    this.log.info("All channels stopped");
+  }
+
+  getChannel(channelName: string, accountId?: string): IChannel | undefined {
+    if (accountId) {
+      return this.channels.get(`${channelName}:${accountId}`);
+    }
+
+    for (const [key, channel] of this.channels) {
+      if (key.startsWith(channelName)) {
+        return channel;
+      }
+    }
+
+    return undefined;
+  }
+
+  async removeChannel(channelName: string, accountId: string): Promise<void> {
+    const key = `${channelName}:${accountId}`;
+    await this.stopChannel(channelName, accountId);
+    this.channels.delete(key);
+    this.log.info(`Removed channel: ${key}`);
+  }
+
+  getAccountConfig(channelName: string, accountId: string): any {
+    const channelConfigs = (this.config.channels ?? {}) as Record<string, any>;
+    const channelConfig = channelConfigs[channelName];
+    if (!channelConfig) return null;
+
+    const accounts = channelConfig.accounts;
+    if (!accounts) return null;
+    return accounts[accountId] || null;
+  }
+
+  async startChannel(channelName: string, accountId: string): Promise<void> {
+    const key = `${channelName}:${accountId}`;
+    let channel = this.channels.get(key);
+
+    if (!channel) {
+      const channelConfigs = (this.config.channels ?? {}) as Record<string, any>;
+      const channelConfig = channelConfigs[channelName];
+      if (!channelConfig) {
+        throw new Error(`Channel configuration not found: ${channelName}`);
+      }
+
+      const accounts = channelConfig.accounts;
+      if (!accounts) {
+        throw new Error(`Accounts configuration not found for channel ${channelName}`);
+      }
+      const accountConfig = accounts[accountId];
+      if (!accountConfig) {
+        throw new Error(`Account configuration not found: ${accountId} for channel ${channelName}`);
+      }
+
+      const fullConfig = { ...channelConfig, ...(accountConfig ?? {}) };
+      await this.createChannel(channelName, accountId, fullConfig as any);
+      channel = this.channels.get(key);
+    }
+
+    if (!channel) {
+      throw new Error(`Failed to instantiate channel: ${key}`);
+    }
+
+    if (channel.isRunning()) {
+      this.log.info(`Channel ${key} is already running`);
+      return;
+    }
+
+    await channel.start();
+    this.log.info(`Started channel: ${key}`);
+  }
+
+  async stopChannel(channelName: string, accountId: string): Promise<void> {
+    const key = `${channelName}:${accountId}`;
+    const channel = this.channels.get(key);
+
+    if (!channel) {
+      this.log.warn(`Channel ${key} not found or not instantiated`);
+      return;
+    }
+
+    if (!channel.isRunning()) {
+      this.log.info(`Channel ${key} is not running`);
+      return;
+    }
+
+    await channel.stop();
+    this.log.info(`Stopped channel: ${key}`);
+  }
+
+  listAllAvailableChannels(): Array<{ name: string; accountId: string; running: boolean; enabled: boolean }> {
+    const available: Array<{ name: string; accountId: string; running: boolean; enabled: boolean }> = [];
+    const channelConfigs = (this.config.channels ?? {}) as Record<string, any>;
+
+    for (const [channelName, channelConfig] of Object.entries(channelConfigs)) {
+      const accounts = channelConfig.accounts;
+      if (!accounts) continue;
+      for (const accountId of Object.keys(accounts)) {
+        const key = `${channelName}:${accountId}`;
+        const channel = this.channels.get(key);
+        available.push({
+          name: channelName,
+          accountId: accountId,
+          running: channel ? channel.isRunning() : false,
+          enabled: channelConfig.enabled !== false,
+        });
+      }
+    }
+    return available;
+  }
+
+  listChannels(): Array<{ name: string; accountId: string; running: boolean }> {
+    return Array.from(this.channels.entries()).map(([key, channel]) => {
+      const [name, accountId] = key.split(":");
+      return {
+        name: name ?? "unknown",
+        accountId: accountId ?? "unknown",
+        running: channel.isRunning(),
+      };
+    });
+  }
+
+  async send(
+    channelName: string,
+    sessionId: string,
+    message: unknown
+  ): Promise<void> {
+    const channel = this.getChannel(channelName);
+
+    if (!channel) {
+      throw new Error(`Channel not found: ${channelName}`);
+    }
+
+    await channel.send(sessionId, message as any);
+  }
+
+  async startTyping(channelName: string, sessionId: string): Promise<void> {
+    const channel = this.getChannel(channelName);
+    if (channel?.startTyping) {
+      await channel.startTyping(sessionId);
+    }
+  }
+
+  async stopTyping(channelName: string, sessionId: string): Promise<void> {
+    const channel = this.getChannel(channelName);
+    if (channel?.stopTyping) {
+      await channel.stopTyping(sessionId);
+    }
+  }
+
+  async markAsRead(channelName: string, sessionId: string, messageId?: string): Promise<void> {
+    const channel = this.getChannel(channelName);
+    if (channel?.markAsRead) {
+      await channel.markAsRead(sessionId, messageId);
+    }
+  }
+
+  async sendAudio(channelName: string, sessionId: string, audio: Buffer, mimeType: string): Promise<void> {
+    const channel = this.getChannel(channelName);
+    if (!channel) {
+      throw new Error(`Channel not found: ${channelName}`);
+    }
+    if (!channel.sendAudio) {
+      throw new Error(`Channel ${channelName} does not support audio`);
+    }
+    await channel.sendAudio(sessionId, audio, mimeType);
+  }
+}
+
+export function createChannelManager(config: Config): ChannelManager {
+  return new ChannelManager(config);
+}