@johpaz/hive 1.7.2 → 1.7.3

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

@@ -1,260 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,383 +0,0 @@
-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);
-}